From f0daa768afcb785554efe5ceda936c8c306a4378 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Mon, 27 Oct 2025 23:33:52 +0500 Subject: [PATCH 1/2] test: add tests to achieve full test code coverage --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/count-falsy/lib/main.js | 2 +- .../ndarray/base/count-falsy/test/test.10d.js | 2927 +++++++++++++++++ .../ndarray/base/count-falsy/test/test.1d.js | 88 + .../ndarray/base/count-falsy/test/test.2d.js | 1197 +++++++ .../ndarray/base/count-falsy/test/test.3d.js | 1383 ++++++++ .../ndarray/base/count-falsy/test/test.4d.js | 1569 +++++++++ .../ndarray/base/count-falsy/test/test.5d.js | 1755 ++++++++++ .../ndarray/base/count-falsy/test/test.6d.js | 1941 +++++++++++ .../ndarray/base/count-falsy/test/test.7d.js | 2127 ++++++++++++ .../ndarray/base/count-falsy/test/test.8d.js | 2349 +++++++++++++ .../ndarray/base/count-falsy/test/test.9d.js | 2569 +++++++++++++++ .../ndarray/base/count-falsy/test/test.js | 13 + .../ndarray/base/count-falsy/test/test.nd.js | 824 +++++ 13 files changed, 18743 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/lib/main.js index 325afeec0c95..1f27966e8ace 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/lib/main.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/lib/main.js @@ -274,7 +274,7 @@ function countFalsy( arrays ) { } // Check whether we were provided an empty ndarray... if ( len === 0 ) { - return true; + return 0; } // Determine whether the ndarray is one-dimensional and thus readily translates to a one-dimensional strided array... if ( ndims === 1 ) { diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js new file mode 100644 index 000000000000..938e5b375b4e --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js @@ -0,0 +1,2927 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ 16, -16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -8, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, -16, 16, -16, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ 16, -16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -8, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 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, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + 2, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, -2, 2, -2, 4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ + 2, + -4, + bsize*8, + -bsize*8, + bsize*16, + -bsize*16, + bsize*32, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (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 = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, -2, -2, -4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + bsize*4, + bsize*4, + -bsize*8, + bsize*8, + -bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + -4, + 4, + -bsize*8, + bsize*8, + -bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1, 1 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16, -16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, -2, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + -bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + -4, + -bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + -4, + -4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1, 1 ]; + st = [ + 2, + -4, + -4, + 4, + bsize*8, + bsize*8, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 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, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js new file mode 100644 index 000000000000..c45be6d8b5d9 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js @@ -0,0 +1,88 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 1-dimensional ndarray', function test( t ) { + var actual; + var x; + + x = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( 'float64', ones( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 1-dimensional ndarray (accessors)', function test( t ) { + var actual; + var x; + + x = ndarray( 'float64', toAccessorArray( zeros( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 1-dimensional ndarray (complex)', function test( t ) { + var actual; + var x; + + x = ndarray( 'complex128', zeros( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( 'complex128', ones( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js new file mode 100644 index 000000000000..8450445df392 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js @@ -0,0 +1,1197 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ 2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ -2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ 2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ -2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ 2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = [ -2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 2-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js new file mode 100644 index 000000000000..0a6470bf4895 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js @@ -0,0 +1,1383 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2 ]; + st = [ bsize*8, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2, 2 ]; + st = [ -4, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2 ]; + st = [ -bsize*8, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 2 ]; + st = [ -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -3, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2 ]; + st = [ bsize*8, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -1, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ 2, -2, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2, 2 ]; + st = [ -1, -2, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (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, 1, 2 ]; + st = [ 2, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ 2, -2, bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 2 ]; + st = [ -1, -2, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 2, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 1, -2, -3 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -2, -2, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js new file mode 100644 index 000000000000..4fdcda45e054 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js @@ -0,0 +1,1569 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ bsize*8, bsize*4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ bsize*8, bsize*4, -bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, -4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ -bsize*4, -bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ -bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, -4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ bsize*4, bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ 2, 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ 2, -2, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 1, 2 ]; + st = [ 2, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (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, 1, 2, 1 ]; + st = [ 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 2, 4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*4, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ 1, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 2, -4, -4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ 2, 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ 2, 2, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 1, 2 ]; + st = [ 2, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js new file mode 100644 index 000000000000..d08c575d6b49 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js @@ -0,0 +1,1755 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2, 2 ]; + st = [ -8, -4, -4, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 8, -4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ 8, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2 ]; + st = [ -bsize*8, -4, 4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 8, -4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ 8, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2 ]; + st = [ -bsize*8, -4, 4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2, 2 ]; + st = [ -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (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, 1, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 2, 4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1 ]; + st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ -2, 4, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ -2, -4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ 2, 4, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1 ]; + st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ -2, 4, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ -2, -4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ 2, 4, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js new file mode 100644 index 000000000000..d3605a19b161 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js @@ -0,0 +1,1941 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 8, -8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ bsize*8, -4, -4, 4, 4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 8, -8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ -bsize*8, -4, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, -4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 8, -8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ -bsize*8, -4, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, -2, 2, -4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 1 ]; + st = [ 2, 4, 4, -4, 8, -bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (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 = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 1 ]; + st = [ 2, 4, 4, -4, 8, -bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, 4, 4, -8, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 1 ]; + st = [ 2, 4, 4, -4, 8, -bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, 4, 4, -8, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js new file mode 100644 index 000000000000..5935e6181e5e --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js @@ -0,0 +1,2127 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 2 ]; + st = [ bsize*16, -8, 8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -16, 16, -16, -8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ bsize*16, -8, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ bsize*16, bsize*16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*16, -bsize*16, -bsize*8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ]; + st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -16, 16, -16, 8, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ -bsize*16, -8, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ]; + st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, -2, 2, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ 2, -4, bsize*8, -bsize*8, bsize*16, -bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 1, 2 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (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 = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, -2, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, -4, 4, -bsize*8, bsize*8, -bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js new file mode 100644 index 000000000000..bf092a01e434 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js @@ -0,0 +1,2349 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 2, 1 ]; + st = [ bsize*16, -8, 8, 4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -bsize*8, + bsize*8, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 16, -16, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; + st = [ bsize*16, -8, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ bsize*16, bsize*16, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, 4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ -8, -8, -4, -4, -2, -2, -1, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 16, -16, 8, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; + st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1 ]; + st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, -2, 2, -2, 4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -4, bsize*8, -bsize*8, bsize*16, -bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (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 = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, -2, -2, -4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ 2, -4, 4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, -2, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; + st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js new file mode 100644 index 000000000000..e8784e923791 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js @@ -0,0 +1,2569 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 2, 1, 1 ]; + st = [ bsize*16, -8, 8, 4, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, -16, 16, -16, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; + st = [ bsize*16, -8, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ bsize*16, bsize*16, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, -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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ bsize*16, -bsize*16, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2, 1, 2, 1 ]; + st = [ -8, -8, -8, -4, -4, -2, -2, -1, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; + st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; + st = [ + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, -2, 2, -2, 4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ 2, -4, bsize*8, -bsize*8, bsize*16, -bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (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 = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, -2, -2, -4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -4, 4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, complex)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; + st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, -2, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.js index 959d9e74dbea..8b2c4a41bb4e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.js @@ -21,6 +21,8 @@ // MODULES // var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); var countFalsy = require( './../lib' ); @@ -31,3 +33,14 @@ tape( 'main export is a function', function test( t ) { t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); t.end(); }); + +tape( 'the function returns `0` if the input is an empty ndarray', function test( t ) { + var actual; + var x; + + x = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' ); + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js new file mode 100644 index 000000000000..ba6aad1bc785 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js @@ -0,0 +1,824 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var countFalsy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countFalsy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + 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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, -16, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 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 = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, same sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -16, 16, -16, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 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, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (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 = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, -2, 2, -2, 4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous, negative strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (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 = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, -2, -2, -4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16, -16, -16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of falsy elements in a n-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 2, 2, 2, 2, 2, 2, 2, -2, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countFalsy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + t.end(); +}); From ff838c6298bf84e13d27e20ed13a79a7572fa176 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Wed, 12 Nov 2025 14:06:56 +0500 Subject: [PATCH 2/2] fix: apply suggestions from code review --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/count-falsy/test/test.10d.js | 120 +++++------------- .../ndarray/base/count-falsy/test/test.1d.js | 4 +- .../ndarray/base/count-falsy/test/test.2d.js | 28 ++-- .../ndarray/base/count-falsy/test/test.3d.js | 32 ++--- .../ndarray/base/count-falsy/test/test.4d.js | 36 +++--- .../ndarray/base/count-falsy/test/test.5d.js | 50 +++----- .../ndarray/base/count-falsy/test/test.6d.js | 56 ++++---- .../ndarray/base/count-falsy/test/test.7d.js | 62 ++++----- .../ndarray/base/count-falsy/test/test.8d.js | 68 ++++------ .../ndarray/base/count-falsy/test/test.9d.js | 92 ++++---------- .../ndarray/base/count-falsy/test/test.nd.js | 20 +-- 11 files changed, 210 insertions(+), 358 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js index 938e5b375b4e..703154b7e2f1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.10d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -220,7 +220,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -251,7 +250,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 2, 1, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -8, 8, 4, -4, 4, 2, 2, 2, 2 ]; @@ -282,7 +280,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -313,7 +310,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2, 2, 2 ]; @@ -344,7 +340,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2, 2, 2, 2 ]; @@ -375,7 +370,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2, 2, 2, 2 ]; @@ -406,7 +400,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ @@ -448,7 +441,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ @@ -490,7 +482,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ @@ -532,7 +523,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ @@ -686,7 +676,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -717,7 +706,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -8, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -748,7 +736,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, bsize*16, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -779,7 +766,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, -bsize*8, 4, -4, 4, 2, 2, 2, 2 ]; @@ -810,7 +796,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2, 2, 2, 2 ]; @@ -841,7 +826,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2, 2, 2, 2 ]; @@ -872,7 +856,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ @@ -914,7 +897,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ @@ -956,7 +938,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ @@ -998,7 +979,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ @@ -1037,7 +1017,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1065,7 +1045,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ]; @@ -1093,7 +1073,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; @@ -1121,7 +1101,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; @@ -1150,9 +1130,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -1181,9 +1160,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -1212,9 +1190,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2, 2, 2 ]; @@ -1243,9 +1220,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2, 2, 2 ]; @@ -1274,9 +1250,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ]; @@ -1305,9 +1280,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2, 2, 2 ]; @@ -1336,9 +1310,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2 ]; @@ -1367,9 +1340,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ @@ -1409,9 +1381,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ @@ -1451,9 +1422,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ @@ -1520,7 +1490,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1663,7 +1633,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -1705,7 +1674,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; st = [ @@ -1747,7 +1715,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -1789,7 +1756,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -1831,7 +1797,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1862,7 +1827,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1893,7 +1857,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; @@ -1924,7 +1887,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; @@ -1955,7 +1917,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; @@ -1986,7 +1947,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; @@ -2129,7 +2089,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2171,7 +2130,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2213,7 +2171,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2255,7 +2212,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32, bsize*32 ]; @@ -2286,7 +2242,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*32, bsize*32, bsize*32 ]; @@ -2317,7 +2272,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; @@ -2348,7 +2302,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; @@ -2379,7 +2332,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; @@ -2410,7 +2362,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; @@ -2441,7 +2392,6 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; @@ -2469,7 +2419,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -2497,7 +2447,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16, -16 ]; @@ -2525,7 +2475,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; @@ -2553,7 +2503,7 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, 2, 2, -2, -4, -8, 8 ]; @@ -2582,9 +2532,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2624,9 +2573,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2666,9 +2614,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ @@ -2708,9 +2655,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1, 1 ]; st = [ @@ -2750,9 +2696,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -2781,9 +2726,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; @@ -2812,9 +2756,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32, bsize*32 ]; @@ -2843,9 +2786,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32, bsize*32 ]; @@ -2874,9 +2816,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, bsize*32 ]; @@ -2905,9 +2846,8 @@ tape( 'the function counts the number of falsy elements in a 10-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16, 16 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js index c45be6d8b5d9..410ec410c151 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.1d.js @@ -57,12 +57,12 @@ tape( 'the function counts the number of falsy elements in a 1-dimensional ndarr var actual; var x; - x = ndarray( 'float64', toAccessorArray( zeros( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); + x = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); actual = countFalsy( [ x ] ); t.strictEqual( actual, 4, 'returns expected value' ); - x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); + x = ndarray( 'generic', toAccessorArray( ones( 8, 'generic' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); actual = countFalsy( [ x ] ); t.strictEqual( actual, 0, 'returns expected value' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js index 8450445df392..bcf7140b098e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.2d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1 ]; st = shape2strides( sh, ord ); @@ -453,7 +453,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2 ]; st = shape2strides( sh, ord ); @@ -481,7 +481,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2 ]; st = [ -2, -1 ]; @@ -509,7 +509,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2 ]; st = [ 4, 2 ]; @@ -537,7 +537,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2 ]; st = [ 4, -2 ]; @@ -566,7 +566,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -597,7 +597,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -655,7 +655,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 4, 1 ]; st = shape2strides( sh, ord ); @@ -1031,7 +1031,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2 ]; st = shape2strides( sh, ord ); @@ -1059,7 +1059,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2 ]; st = [ -1, -2 ]; @@ -1087,7 +1087,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2 ]; st = [ 2, 4 ]; @@ -1115,7 +1115,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2 ]; st = [ -2, 4 ]; @@ -1144,7 +1144,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1175,7 +1175,7 @@ tape( 'the function counts the number of falsy elements in a 2-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js index 0a6470bf4895..25f92fe3de80 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.3d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1 ]; st = shape2strides( sh, ord ); @@ -515,7 +515,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -543,7 +543,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2, 2 ]; st = [ -2, -2, -1 ]; @@ -571,7 +571,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2 ]; st = [ 4, 4, 2 ]; @@ -599,7 +599,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2 ]; st = [ -3, -2, 1 ]; @@ -628,7 +628,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -659,7 +659,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -690,7 +690,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -748,7 +748,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 4, 1, 1 ]; st = shape2strides( sh, ord ); @@ -1186,7 +1186,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1214,7 +1214,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2, 2 ]; st = [ -1, -2, -4 ]; @@ -1242,7 +1242,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2 ]; st = [ 2, 4, 4 ]; @@ -1270,7 +1270,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2 ]; st = [ 1, -2, -3 ]; @@ -1299,7 +1299,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1330,7 +1330,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1361,7 +1361,7 @@ tape( 'the function counts the number of falsy elements in a 3-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js index 4fdcda45e054..5ad29547b406 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.4d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -577,7 +577,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1 ]; st = shape2strides( sh, ord ); @@ -605,7 +605,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 2, 1, 2 ]; st = [ -4, -2, -2, -1 ]; @@ -633,7 +633,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1 ]; st = [ 4, 4, 2, 2 ]; @@ -661,7 +661,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1 ]; st = [ 4, -4, -2, 2 ]; @@ -690,7 +690,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -721,7 +721,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -752,7 +752,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -783,7 +783,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -841,7 +841,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1341,7 +1341,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1 ]; st = shape2strides( sh, ord ); @@ -1369,7 +1369,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 2, 1, 2 ]; st = [ -1, -2, -4, -4 ]; @@ -1397,7 +1397,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1 ]; st = [ 2, 4, 4, 8 ]; @@ -1425,7 +1425,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1 ]; st = [ 2, -4, -4, 8 ]; @@ -1454,7 +1454,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1485,7 +1485,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1516,7 +1516,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1547,7 +1547,7 @@ tape( 'the function counts the number of falsy elements in a 4-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js index d08c575d6b49..969e24555143 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.5d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -639,7 +639,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -667,7 +667,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ -4, -4, -2, -2, -1 ]; @@ -695,7 +695,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 8, 8, 4, 4, 2 ]; @@ -723,7 +723,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 8, 8, -4, -4, -2 ]; @@ -752,9 +752,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2 ]; st = [ 8, -8, -4, 4, 2 ]; @@ -783,9 +782,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2 ]; st = [ -bsize*8, -4, 4, -4, -2 ]; @@ -814,9 +812,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2 ]; st = [ bsize*8, bsize*8, -4, 4, 2 ]; @@ -845,9 +842,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 2 ]; st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; @@ -876,9 +872,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2 ]; st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; @@ -934,7 +929,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1496,7 +1491,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1524,7 +1519,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ -1, -2, -2, -4, -4 ]; @@ -1552,7 +1547,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 2, 4, 4, 8, 8 ]; @@ -1580,7 +1575,7 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 2, -4, -4, -8, -8 ]; @@ -1609,9 +1604,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2 ]; st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; @@ -1640,9 +1634,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 2, 1, 1 ]; st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; @@ -1671,9 +1664,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2 ]; st = [ -2, 4, -4, bsize*8, bsize*8 ]; @@ -1702,9 +1694,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 2 ]; st = [ -2, -4, -4, 4, bsize*8 ]; @@ -1733,9 +1724,8 @@ tape( 'the function counts the number of falsy elements in a 5-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2 ]; st = [ 2, 4, -4, 8, -8 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js index d3605a19b161..573cb8a28fe7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.6d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -701,7 +701,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -729,7 +729,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ -8, -8, -4, -2, -2, -1 ]; @@ -757,7 +757,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 8, 4, 4, 2 ]; @@ -785,7 +785,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 8, -4, -4, -2 ]; @@ -814,9 +814,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 1, 2 ]; st = [ 8, -8, -4, 4, 4, 2 ]; @@ -845,9 +844,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 1, 2 ]; st = [ -bsize*8, -4, -4, 4, 4, 2 ]; @@ -876,9 +874,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 1, 2 ]; st = [ bsize*8, bsize*8, -4, 4, 4, 2 ]; @@ -907,9 +904,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2 ]; st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; @@ -938,9 +934,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 1, bsize*2, 2 ]; st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ]; @@ -969,9 +964,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; 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 ]; @@ -1027,7 +1021,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1651,7 +1645,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1679,7 +1673,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ -1, -1, -1, -2, -4, -4 ]; @@ -1707,7 +1701,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 4, 8, 8 ]; @@ -1735,7 +1729,7 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, -4, -8, -8 ]; @@ -1764,9 +1758,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 1, 2 ]; st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ]; @@ -1795,9 +1788,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 1, 2 ]; st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; @@ -1826,9 +1818,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 1, 2 ]; st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; @@ -1857,9 +1848,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2 ]; st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; @@ -1888,9 +1878,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, bsize*2, 1 ]; st = [ 2, 4, 4, -4, 8, -bsize*16 ]; @@ -1919,9 +1908,8 @@ tape( 'the function counts the number of falsy elements in a 6-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2 ]; st = [ 2, 4, 4, -8, 8, -8 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js index 5935e6181e5e..d91cc4f04d8a 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.7d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -763,7 +763,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -791,7 +791,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2, 1, 2 ]; st = [ -8, -8, -4, -4, -2, -2, -1 ]; @@ -819,7 +819,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 8, 4, 4, 2 ]; @@ -847,7 +847,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = [ -16, 16, -16, 8, -4, -2, -2 ]; @@ -876,9 +876,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; st = [ 16, -16, 8, 8, -4, 4, 2 ]; @@ -907,9 +906,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; st = [ -bsize*16, -8, 8, 8, -4, 4, 2 ]; @@ -938,9 +936,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2 ]; @@ -969,9 +966,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; @@ -1000,9 +996,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2 ]; @@ -1031,9 +1026,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ]; st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ]; @@ -1062,9 +1056,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ]; @@ -1120,7 +1113,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1806,7 +1799,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1834,7 +1827,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2, 1, 2 ]; st = [ -1, -2, -2, -4, -4, -8, -8 ]; @@ -1862,7 +1855,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, 4, 8, 8 ]; @@ -1890,7 +1883,7 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, -4, -8, -8 ]; @@ -1919,9 +1912,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; @@ -1950,9 +1942,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; @@ -1981,9 +1972,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; @@ -2012,9 +2002,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ]; @@ -2043,9 +2032,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; @@ -2074,9 +2062,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; @@ -2105,9 +2092,8 @@ tape( 'the function counts the number of falsy elements in a 7-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js index bf092a01e434..eb8a4c8a77ef 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.8d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -852,7 +852,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -880,7 +880,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ -8, -8, -4, -4, -2, -2, -1, -1 ]; @@ -908,7 +908,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 16, 8, 4, 4, 2 ]; @@ -936,7 +936,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, -16, 16, -16, 8, -4, -2, -2 ]; @@ -965,9 +965,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ 16, -16, 8, 8, -4, 4, 2, 2 ]; @@ -996,9 +995,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2 ]; @@ -1027,9 +1025,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2 ]; @@ -1058,9 +1055,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2 ]; @@ -1089,9 +1085,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2 ]; @@ -1120,9 +1115,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1 ]; st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2 ]; @@ -1151,9 +1145,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2 ]; @@ -1182,9 +1175,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2 ]; st = [ @@ -1249,7 +1241,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1997,7 +1989,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -2025,7 +2017,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ -1, -2, -2, -4, -4, -8, -8, -16 ]; @@ -2053,7 +2045,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, 2, 4, 8, 8 ]; @@ -2081,7 +2073,7 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, -2, -4, -8, 8 ]; @@ -2110,9 +2102,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; @@ -2141,9 +2132,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1 ]; st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; @@ -2172,9 +2162,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1 ]; st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32 ]; @@ -2203,9 +2192,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32 ]; @@ -2234,9 +2222,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16 ]; @@ -2265,9 +2252,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32 ]; @@ -2296,9 +2282,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32 ]; @@ -2327,9 +2312,8 @@ tape( 'the function counts the number of falsy elements in a 8-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js index e8784e923791..f9b0c0d0f1ea 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.9d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -937,7 +937,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -965,7 +965,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ -8, -8, -8, -4, -4, -2, -2, -1, -1 ]; @@ -993,7 +993,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; @@ -1021,7 +1021,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; @@ -1050,9 +1050,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; st = [ 16, -16, 8, 8, -4, 4, 2, 2, 2 ]; @@ -1081,9 +1080,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; st = [ -bsize*16, -8, 8, 8, -4, 4, 2, 2, 2 ]; @@ -1112,9 +1110,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2, 2, 2 ]; @@ -1143,9 +1140,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, bsize*2, 1, 1, 2, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2, 2, 2 ]; @@ -1174,9 +1170,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2, 2, 2 ]; @@ -1205,9 +1200,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, 2, 1, bsize*2, 2, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2, 2, 2 ]; @@ -1236,9 +1230,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2, 2, 2 ]; @@ -1267,9 +1260,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, bsize*2, 1 ]; st = [ @@ -1308,9 +1300,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; - bsize = blockSize( dt ); sh = [ 1, 2, 1, 2, 1, 2, 1, 1, bsize*2 ]; st = [ @@ -1376,7 +1367,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1519,7 +1510,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1550,7 +1540,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; st = [ 2, -4, bsize*8, -bsize*8, bsize*16, -bsize*16, bsize*32, bsize*32, bsize*32 ]; @@ -1581,7 +1570,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1612,7 +1600,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1643,7 +1630,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -1674,7 +1660,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*16, bsize*16 ]; @@ -1705,7 +1690,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; @@ -1736,7 +1720,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; @@ -1767,7 +1750,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'float64'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; @@ -1910,7 +1892,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -1941,7 +1922,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -1972,7 +1952,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -4, 4, -bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -2003,7 +1982,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32 ]; @@ -2034,7 +2012,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -2065,7 +2042,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32 ]; @@ -2096,7 +2072,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; @@ -2127,7 +2102,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; @@ -2158,7 +2132,6 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr dt = 'complex128'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; @@ -2186,7 +2159,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -2214,7 +2187,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1 ]; st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16 ]; @@ -2242,7 +2215,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; @@ -2270,7 +2243,7 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, 2, -2, -4, -8, 8 ]; @@ -2299,9 +2272,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ bsize*2, 1, 2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -2330,9 +2302,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, bsize*2, 1, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -2361,9 +2332,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, bsize*2, 1, 2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*32, bsize*32 ]; @@ -2392,9 +2362,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 1, bsize*2, 1, 2, 2, 1, 1 ]; st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*32, bsize*32 ]; @@ -2423,9 +2392,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, bsize*2, 1, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; @@ -2454,9 +2422,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 8, bsize*16, bsize*32, bsize*32 ]; @@ -2485,9 +2452,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, bsize*2, 1, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, bsize*32, bsize*32 ]; @@ -2516,9 +2482,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, bsize*2, 1 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, bsize*32 ]; @@ -2547,9 +2512,8 @@ tape( 'the function counts the number of falsy elements in a 9-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; - bsize = blockSize( dt ); sh = [ 2, 1, 2, 1, 2, 1, 1, 1, bsize*2 ]; st = [ 2, -4, -4, 8, 8, 16, 16, 16, 16 ]; diff --git a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js index ba6aad1bc785..282eeef25ce9 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-falsy/test/test.nd.js @@ -76,7 +76,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -328,7 +328,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -356,7 +356,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1 ]; st = [ -8, -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ]; @@ -384,7 +384,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ]; @@ -412,7 +412,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 16, 16, 16, 16, -16, 16, -16, 8, -4, -2, -2 ]; @@ -468,7 +468,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -720,7 +720,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -748,7 +748,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; st = [ -1, -2, -2, -4, -4, -8, -8, -16, -16, -16, -16 ]; @@ -776,7 +776,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1 ]; st = [ 2, 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ]; @@ -804,7 +804,7 @@ tape( 'the function counts the number of falsy elements in a n-dimensional ndarr var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; st = [ 2, 2, 2, 2, 2, 2, 2, -2, -4, -8, 8 ];