diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.0d.js new file mode 100644 index 000000000000..09a0c75cf0ff --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.0d.js @@ -0,0 +1,93 @@ +/** +* @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 Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 0-dimensional ndarray pass a test implemented by a predicate function', function test( t ) { + var actual; + var x; + var n; + + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + x = scalar2ndarray( 0.0, { + 'dtype': 'float64' + }); + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = scalar2ndarray( 1.0, { + 'dtype': 'float64' + }); + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0.0; + } +}); + +tape( 'the function tests whether at `n` elements in a 0-dimensional ndarray pass a test implemented by a predicate function (accessors)', function test( t ) { + var actual; + var x; + var n; + + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + x = scalar2ndarray( new Complex128( 0.0, 0.0 ), { + 'dtype': 'complex128' + }); + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = scalar2ndarray( new Complex128( 1.0, 1.0 ), { + 'dtype': 'complex128' + }); + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.10d.js new file mode 100644 index 000000000000..40fb43fd7895 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.10d.js @@ -0,0 +1,2912 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, -2, -2, -2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -4, -4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -2, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, 4, 2, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ + bsize*8, + -bsize*8, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*8, + -bsize*8, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*8, + -bsize*8, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + 2, + -bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + -2, + 4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + -2, + 4, + 4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1, 1 ]; + st = [ + -2, + 4, + 4, + 8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + -2, + bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ + 2, + -4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + 2, + -4, + 4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1, 1 ]; + st = [ + 2, + -4, + 4, + 8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.1d.js new file mode 100644 index 000000000000..0bd7c38cc450 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.1d.js @@ -0,0 +1,219 @@ +/** +* @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 ones = require( '@stdlib/array/ones' ); +var zeros = require( '@stdlib/array/zeros' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 1-dimensional ndarray pass a test implemented by a predicate function', function test( t ) { + var actual; + var x; + var n; + + x = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( 'float64', ones( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 0-dimensional ndarray pass a test implemented by a predicate function (accessors)', function test( t ) { + var actual; + var xbuf; + var x; + var n; + + xbuf = zeros( 6*2, 'float64' ); + x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 6*2, 'float64' ); + x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var x; + var n; + + x = new ndarray( 'float64', ones( 8, 'float64'), [ 4 ], [ 2 ], 0, 'row-major' ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0 ], + [ 1 ], + [ 2 ], + [ 3 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var x; + var n; + + xbuf = ones( 6*2, 'float64' ); + x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0 ], + [ 1 ], + [ 2 ], + [ 3 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.2d.js new file mode 100644 index 000000000000..f09075a47ec0 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.2d.js @@ -0,0 +1,1414 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0 ], + [ 0, 1 ], + [ 1, 0 ], + [ 1, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0 ], + [ 0, 1 ], + [ 1, 0 ], + [ 1, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ -4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ bsize*4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0 ], + [ 1, 0 ], + [ 0, 1 ], + [ 1, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0 ], + [ 1, 0 ], + [ 0, 1 ], + [ 1, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ -1, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 2, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ -2, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ -2, bsize*2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 2-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ 2, -4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.3d.js new file mode 100644 index 000000000000..967e151b4200 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.3d.js @@ -0,0 +1,1576 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0 ], + [ 0, 0, 1 ], + [ 1, 0, 0 ], + [ 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0 ], + [ 0, 0, 1 ], + [ 1, 0, 0 ], + [ 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1 ]; + st = [ bsize*4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1 ]; + st = [ bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0 ], + [ 1, 0, 0 ], + [ 0, 0, 1 ], + [ 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0 ], + [ 1, 0, 0 ], + [ 0, 0, 1 ], + [ 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 2, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1 ]; + st = [ -2, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -1, -2, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 2, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -2, bsize*4, bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1 ]; + st = [ 2, -4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 3-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.4d.js new file mode 100644 index 000000000000..c4cab7e6b567 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.4d.js @@ -0,0 +1,1738 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0 ], + [ 0, 0, 0, 1 ], + [ 0, 1, 0, 0 ], + [ 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0 ], + [ 0, 0, 0, 1 ], + [ 0, 1, 0, 0 ], + [ 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ bsize*4, -2, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ -2, -2, -1, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ bsize*4, -2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0 ], + [ 1, 0, 0, 0 ], + [ 0, 0, 1, 0 ], + [ 1, 0, 1, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 4, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 4, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0 ], + [ 1, 0, 0, 0 ], + [ 0, 0, 1, 0 ], + [ 1, 0, 1, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( 8, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ 2, -bsize*4, bsize*4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ -2, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ -2, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ -2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( 8*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -2, bsize*4, bsize*4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ 2, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 4-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.5d.js new file mode 100644 index 000000000000..599612b8301b --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.5d.js @@ -0,0 +1,1948 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1 ], + [ 1, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1 ], + [ 1, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1 ], + [ 1, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1 ], + [ 1, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -4, -4, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1 ], + [ 1, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 1 ], + [ 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1 ], + [ 1, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 1 ], + [ 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -2, 4, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -2, bsize*4, bsize*4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 5-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.6d.js new file mode 100644 index 000000000000..644f85d822cc --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.6d.js @@ -0,0 +1,2110 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 1, 0, 1 ], + [ 0, 1, 0, 0, 0, 0 ], + [ 0, 1, 0, 0, 0, 1 ], + [ 0, 1, 0, 1, 0, 0 ], + [ 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 1, 0, 1 ], + [ 0, 1, 0, 0, 0, 0 ], + [ 0, 1, 0, 0, 0, 1 ], + [ 0, 1, 0, 1, 0, 0 ], + [ 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1 ]; + st = [ -8, 8, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*8, -4, -4, -2, -2, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -bsize*8, -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1 ]; + st = [ -8, 8, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0 ], + [ 1, 0, 0, 0, 1, 0 ], + [ 0, 0, 1, 0, 1, 0 ], + [ 1, 0, 1, 0, 1, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0 ], + [ 1, 0, 0, 0, 1, 0 ], + [ 0, 0, 1, 0, 1, 0 ], + [ 1, 0, 1, 0, 1, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ 2, 4, 4, 8, 8, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ -2, 4, 4, 8, 8, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1 ]; + st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1 ]; + st = [ -2, 4, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1 ]; + st = [ -2, 4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1 ]; + st = [ -2, 4, 4, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ -1, -2, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ 2, 4, 4, 8, 8, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1 ]; + st = [ -2, 4, 4, 8, 8, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1 ]; + st = [ -2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1 ]; + st = [ 2, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1 ]; + st = [ 2, -4, 4, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 6-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.7d.js new file mode 100644 index 000000000000..fbe106acbf80 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.7d.js @@ -0,0 +1,2272 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, -2, -2, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -4, -4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ -2, 4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ -2, 4, 4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ -2, 4, 4, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1 ]; + st = [ -2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ 2, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 7-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.8d.js new file mode 100644 index 000000000000..9cd0a5275906 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.8d.js @@ -0,0 +1,2461 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, -2, -2, -2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -4, -4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + 2, + -bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ -2, 4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ -2, 4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1 ]; + st = [ + -2, + bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ 2, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 8-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.9d.js new file mode 100644 index 000000000000..8d271c88fc49 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.9d.js @@ -0,0 +1,2676 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, -2, -2, -2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -4, -4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*8, + -bsize*8, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, 4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, 2, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*8, -bsize*8, bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*8, + -bsize*8, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*8, + -bsize*8, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ + 2, + -bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ + -2, + 4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) { + var actual; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ -2, 4, 4, 8, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 1, 1, 1 ]; + st = [ + -2, + bsize*4, + bsize*4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 1, 1, 1 ]; + st = [ + 2, + -4, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 9-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var actual; + var bsize; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, -4, 4, 8, 8, 8, 8, 8, 8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.js index 1cdd15f7997b..defaf98b555e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.js @@ -21,6 +21,10 @@ // MODULES // var tape = require( 'tape' ); +var ones = require( '@stdlib/array/ones' ); +var zeros = require( '@stdlib/array/zeros' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); var someBy = require( './../lib' ); @@ -32,4 +36,42 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -// TODO: add tests +tape( 'the function returns `false` if provided an empty input ndarray', function test( t ) { + var actual; + var x; + var n; + + x = ndarray( 'float64', ones( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0.0; + } +}); + +tape( 'the function returns `true` if provided `n` parameter is less than zero', function test( t ) { + var actual; + var x; + var n; + + x = ndarray( 'float64', zeros( 2, 'float64' ), [ 2 ], [ 1 ], 0, 'row-major' ); + n = scalar2ndarray( -1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0.0; + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.nd.js new file mode 100644 index 000000000000..453d576b7398 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/some-by/test/test.nd.js @@ -0,0 +1,1137 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var someBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof someBy, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ], + [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, -8, 8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( v ); + indices.push( idx ); + arrays.push( arr ); + return v !== 0.0; + } +}); + +tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) { + var expected; + var indices; + var values; + var arrays; + var actual; + var xbuf; + var ctx; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 8, { + 'dtype': 'generic' + }); + + indices = []; + values = []; + arrays = []; + + ctx = { + 'count': 0 + }; + actual = someBy( [ x, n ], clbk, ctx ); + + t.strictEqual( actual, true, 'returns expected value' ); + t.strictEqual( ctx.count, 8, 'returns expected value' ); + + expected = [ + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ], + [ 1.0, 1.0 ] + ]; + t.deepEqual( values, expected, 'returns expected value' ); + + expected = [ + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ], + [ 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ] + ]; + t.deepEqual( indices, expected, 'returns expected value' ); + + expected = [ + x, + x, + x, + x, + x, + x, + x, + x + ]; + t.deepEqual( arrays, expected, 'returns expected value' ); + + t.end(); + + function clbk( v, idx, arr ) { + this.count += 1; // eslint-disable-line no-invalid-this + values.push( [ real( v ), imag( v ) ] ); + indices.push( idx ); + arrays.push( arr ); + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 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 ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var actual; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return v !== 0; + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ -1, -2, -2, -4, -4, -8, -8, -8, -8, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*2, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +}); + +tape( 'the function tests whether at `n` elements in a 10-dimensional ndarray pass a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var actual; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var n; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1 ]; + st = [ -2, 4, 4, 8, 8, 16, 16, 16, 16, 16, 16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + n = scalar2ndarray( 1, { + 'dtype': 'generic' + }); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, false, 'returns expected value' ); + + xbuf = ones( numel( sh )*4, 'float64' ); + x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord ); + + actual = someBy( [ x, n ], clbk ); + t.strictEqual( actual, true, 'returns expected value' ); + + t.end(); + + function clbk( v ) { + return ( real( v ) !== 0.0 && imag( v ) !== 0.0 ); + } +});