From 0152682555c81676240e1d21de0947494632525b Mon Sep 17 00:00:00 2001 From: headlessNode Date: Sun, 26 Oct 2025 17:51:21 +0500 Subject: [PATCH 1/3] test: add tests to achieve complete 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-truthy/lib/main.js | 2 +- .../base/count-truthy/test/test.10d.js | 2916 +++++++++++++++++ .../ndarray/base/count-truthy/test/test.1d.js | 88 + .../ndarray/base/count-truthy/test/test.2d.js | 1197 +++++++ .../ndarray/base/count-truthy/test/test.3d.js | 1383 ++++++++ .../ndarray/base/count-truthy/test/test.4d.js | 1569 +++++++++ .../ndarray/base/count-truthy/test/test.5d.js | 1755 ++++++++++ .../ndarray/base/count-truthy/test/test.6d.js | 1941 +++++++++++ .../ndarray/base/count-truthy/test/test.7d.js | 2127 ++++++++++++ .../ndarray/base/count-truthy/test/test.8d.js | 2340 +++++++++++++ .../ndarray/base/count-truthy/test/test.9d.js | 2569 +++++++++++++++ .../ndarray/base/count-truthy/test/test.js | 14 + .../ndarray/base/count-truthy/test/test.nd.js | 824 +++++ 13 files changed, 18724 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/lib/main.js index fa3112c91862..4781fbd9dcae 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/lib/main.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/lib/main.js @@ -274,7 +274,7 @@ function countTruthy( 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-truthy/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js new file mode 100644 index 000000000000..fbee78528c13 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js @@ -0,0 +1,2916 @@ +/** +* @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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js new file mode 100644 index 000000000000..5dfa8d1108d8 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( 'float64', ones( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( 'complex128', ones( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js new file mode 100644 index 000000000000..d49e2553645b --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js new file mode 100644 index 000000000000..830f9ddd9d97 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js new file mode 100644 index 000000000000..d2cdff00d0fe --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*4, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js new file mode 100644 index 000000000000..c97bed10eb58 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js new file mode 100644 index 000000000000..c06422e5fada --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*8, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js new file mode 100644 index 000000000000..c11cb5a107e6 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js new file mode 100644 index 000000000000..d8df905460a4 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js @@ -0,0 +1,2340 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js new file mode 100644 index 000000000000..030162d00139 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy 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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, bsize*16, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js index 5ed366f4bb19..5e108dc79cb6 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); @@ -31,3 +33,15 @@ tape( 'main export is a function', function test( t ) { t.strictEqual( typeof countTruthy, '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 = countTruthy( [ x ] ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js new file mode 100644 index 000000000000..05d36539d1c9 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/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 countTruthy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof countTruthy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, ones( 16, dt ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 16, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 4, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function counts the number of truthy elements in a 11-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 = countTruthy( [ x ] ); + t.strictEqual( actual, 0, 'returns expected value' ); + + x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord ); + + actual = countTruthy( [ x ] ); + t.strictEqual( actual, 8, 'returns expected value' ); + + t.end(); +}); From 136b320ae3fbf8fd64067cd917f67303ee8cd17f Mon Sep 17 00:00:00 2001 From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> Date: Sun, 26 Oct 2025 18:01:13 +0500 Subject: [PATCH 2/3] chore: fix expectation Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> --- lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js index 5e108dc79cb6..147066019604 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.js @@ -41,7 +41,7 @@ tape( 'the function returns `0` if the input is an empty ndarray', function test x = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' ); actual = countTruthy( [ x ] ); - t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( actual, 0, 'returns expected value' ); t.end(); }); From ded15a419e1617ab34e7492795fe1145f3f1d4f7 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Wed, 12 Nov 2025 19:29:13 +0500 Subject: [PATCH 3/3] 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 --- --- .../base/count-truthy/test/test.10d.js | 60 +++++++++---------- .../ndarray/base/count-truthy/test/test.1d.js | 4 +- .../ndarray/base/count-truthy/test/test.2d.js | 28 ++++----- .../ndarray/base/count-truthy/test/test.3d.js | 32 +++++----- .../ndarray/base/count-truthy/test/test.4d.js | 36 +++++------ .../ndarray/base/count-truthy/test/test.5d.js | 40 ++++++------- .../ndarray/base/count-truthy/test/test.6d.js | 44 +++++++------- .../ndarray/base/count-truthy/test/test.7d.js | 48 +++++++-------- .../ndarray/base/count-truthy/test/test.8d.js | 52 ++++++++-------- .../ndarray/base/count-truthy/test/test.9d.js | 56 ++++++++--------- .../ndarray/base/count-truthy/test/test.nd.js | 20 +++---- 11 files changed, 210 insertions(+), 210 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js index fbee78528c13..2c042a9810b6 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.10d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ); @@ -1026,7 +1026,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ); @@ -1054,7 +1054,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -1082,7 +1082,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -1110,7 +1110,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -1139,7 +1139,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1170,7 +1170,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1201,7 +1201,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1232,7 +1232,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1263,7 +1263,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1294,7 +1294,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1325,7 +1325,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1356,7 +1356,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1398,7 +1398,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1440,7 +1440,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1509,7 +1509,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ); @@ -2458,7 +2458,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ); @@ -2486,7 +2486,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -2514,7 +2514,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -2542,7 +2542,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda 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 ]; @@ -2571,7 +2571,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2613,7 +2613,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2655,7 +2655,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2697,7 +2697,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2739,7 +2739,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2770,7 +2770,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2801,7 +2801,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2832,7 +2832,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2863,7 +2863,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2894,7 +2894,7 @@ tape( 'the function counts the number of truthy elements in a 10-dimensional nda var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js index 5dfa8d1108d8..270f68868882 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.1d.js @@ -57,12 +57,12 @@ tape( 'the function counts the number of truthy elements in a 1-dimensional ndar 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 = countTruthy( [ x ] ); t.strictEqual( actual, 0, '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 = countTruthy( [ x ] ); t.strictEqual( actual, 4, 'returns expected value' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js index d49e2553645b..1b653c379b2f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.2d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar 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 truthy elements in a 2-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js index 830f9ddd9d97..9827746ceb55 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.3d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar 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 truthy elements in a 3-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js index d2cdff00d0fe..0aed5ba1069c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.4d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar 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 truthy elements in a 4-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js index c97bed10eb58..e31c925a18cc 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.5d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar 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 truthy elements in a 5-dimensional ndar 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 truthy elements in a 5-dimensional ndar 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 truthy elements in a 5-dimensional ndar 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 truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 8, 8, -4, -4, -2 ]; @@ -752,7 +752,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar 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 truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -814,7 +814,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -845,7 +845,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -876,7 +876,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -934,7 +934,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1496,7 +1496,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1524,7 +1524,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar 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 +1552,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar 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 +1580,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 2, 1, 2, 1, 2 ]; st = [ 2, -4, -4, -8, -8 ]; @@ -1609,7 +1609,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1640,7 +1640,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1671,7 +1671,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1702,7 +1702,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1733,7 +1733,7 @@ tape( 'the function counts the number of truthy elements in a 5-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js index c06422e5fada..a70386ada3d7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.6d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar 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 truthy elements in a 6-dimensional ndar 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 truthy elements in a 6-dimensional ndar 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 truthy elements in a 6-dimensional ndar 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 truthy elements in a 6-dimensional ndar 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,7 +814,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -845,7 +845,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -876,7 +876,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -907,7 +907,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -938,7 +938,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -969,7 +969,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1027,7 +1027,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1651,7 +1651,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -1679,7 +1679,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar 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 +1707,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar 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 +1735,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar 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,7 +1764,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1795,7 +1795,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1826,7 +1826,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1857,7 +1857,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1888,7 +1888,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1919,7 +1919,7 @@ tape( 'the function counts the number of truthy elements in a 6-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js index c11cb5a107e6..917a0979a3ca 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.7d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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 truthy elements in a 7-dimensional ndar 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 truthy elements in a 7-dimensional ndar 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 truthy elements in a 7-dimensional ndar 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 truthy elements in a 7-dimensional ndar 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,7 +876,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -907,7 +907,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -938,7 +938,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -969,7 +969,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1000,7 +1000,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1031,7 +1031,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1062,7 +1062,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1120,7 +1120,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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 +1806,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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 +1834,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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 +1862,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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 +1890,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar 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,7 +1919,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1950,7 +1950,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -1981,7 +1981,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2012,7 +2012,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2043,7 +2043,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2074,7 +2074,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2105,7 +2105,7 @@ tape( 'the function counts the number of truthy elements in a 7-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js index d8df905460a4..0980a870c7e2 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.8d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; st = shape2strides( sh, ord ); @@ -843,7 +843,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -871,7 +871,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -899,7 +899,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -927,7 +927,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -956,7 +956,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -987,7 +987,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1018,7 +1018,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1049,7 +1049,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1080,7 +1080,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1111,7 +1111,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1142,7 +1142,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1173,7 +1173,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1240,7 +1240,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ]; st = shape2strides( sh, ord ); @@ -1988,7 +1988,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; st = shape2strides( sh, ord ); @@ -2016,7 +2016,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -2044,7 +2044,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -2072,7 +2072,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar 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 ]; @@ -2101,7 +2101,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2132,7 +2132,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2163,7 +2163,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2194,7 +2194,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2225,7 +2225,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2256,7 +2256,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2287,7 +2287,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2318,7 +2318,7 @@ tape( 'the function counts the number of truthy elements in a 8-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js index 030162d00139..d254a058f5cc 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.9d.js @@ -77,7 +77,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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 truthy elements in a 9-dimensional ndar 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 truthy elements in a 9-dimensional ndar 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 truthy elements in a 9-dimensional ndar 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 truthy elements in a 9-dimensional ndar 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,7 +1050,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1081,7 +1081,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1112,7 +1112,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1143,7 +1143,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1174,7 +1174,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1205,7 +1205,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1236,7 +1236,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1267,7 +1267,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1308,7 +1308,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'row-major'; bsize = blockSize( dt ); @@ -1376,7 +1376,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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 ); @@ -2186,7 +2186,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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 +2214,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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 +2242,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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 +2270,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar 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,7 +2299,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2330,7 +2330,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2361,7 +2361,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2392,7 +2392,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2423,7 +2423,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2454,7 +2454,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2485,7 +2485,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2516,7 +2516,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); @@ -2547,7 +2547,7 @@ tape( 'the function counts the number of truthy elements in a 9-dimensional ndar var o; var x; - dt = 'float64'; + dt = 'generic'; ord = 'column-major'; bsize = blockSize( dt ); diff --git a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js index 05d36539d1c9..40052eeeb1e1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js +++ b/lib/node_modules/@stdlib/ndarray/base/count-truthy/test/test.nd.js @@ -76,7 +76,7 @@ tape( 'the function counts the number of truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 truthy elements in a 11-dimensional nda 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 ];