From 865a3385981a851db49e6786ec01e4f5117f0b99 Mon Sep 17 00:00:00 2001 From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> Date: Fri, 26 Jul 2024 02:32:53 +0500 Subject: [PATCH] test: add tests to `ndarray/base/nullary` PR-URL: https://github.com/stdlib-js/stdlib/pull/2663 Closes: https://github.com/stdlib-js/stdlib/issues/2229 Co-authored-by: Athan Reines Reviewed-by: Athan Reines --- .../ndarray/base/nullary/test/test.10d.js | 1969 +++++++++++++++-- 1 file changed, 1769 insertions(+), 200 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/nullary/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/nullary/test/test.10d.js index 3ddf3244050..cf4c655eb90 100644 --- a/lib/node_modules/@stdlib/ndarray/base/nullary/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/nullary/test/test.10d.js @@ -32,6 +32,9 @@ var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); var numel = require( '@stdlib/ndarray/base/numel' ); +var dfill = require( '@stdlib/blas/ext/base/dfill' ); +var gfill = require( '@stdlib/blas/ext/base/gfill' ); +var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); var nullary = require( './../lib' ); @@ -107,6 +110,25 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d t.end(); }); +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + + x = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous)', function test( t ) { var expected; var ord; @@ -141,7 +163,7 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -153,37 +175,29 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d dt = 'float64'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); nullary( [ x ], constantFunction( 10.0 ) ); expected = new Float64Array([ 10.0, 10.0, - 0.0, - 0.0, - 10.0, 10.0, - 0.0, - 0.0, 10.0, 10.0, - 0.0, - 0.0, 10.0, 10.0, - 0.0, - 0.0 + 10.0 ]); t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { var expected; var ord; var sh; @@ -195,7 +209,7 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d dt = 'float64'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); @@ -225,7 +239,7 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { var expected; var ord; var sh; @@ -234,41 +248,42 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var o; var x; - dt = 'complex128'; + dt = 'float64'; ord = 'row-major'; sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = shape2strides( sh, ord ); + st = [ 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); - nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Complex128Array( [ - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, + expected = new Float64Array([ 10.0, 10.0, + 0.0, + 0.0, 10.0, 10.0, + 0.0, + 0.0, 10.0, 10.0, + 0.0, + 0.0, 10.0, 10.0, - 10.0 - ] ); - t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -276,57 +291,29 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var o; var x; - dt = 'complex128'; + dt = 'float64'; ord = 'row-major'; - sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); - nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Complex128Array([ - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0 - ]); - t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -334,57 +321,29 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var o; var x; - dt = 'complex128'; + dt = 'float64'; ord = 'row-major'; - sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); - nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Complex128Array([ - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0, - 10.0, - 10.0, - 10.0, - 10.0, - 0.0, - 0.0, - 0.0, - 0.0 - ]); - t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -393,28 +352,28 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var x; dt = 'float64'; - ord = 'column-major'; - sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; - st = shape2strides( sh, ord ); + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Float64Array([ - 10.0, - 10.0, - 10.0, - 10.0 - ]); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -422,33 +381,29 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var o; var x; - dt = 'complex128'; - ord = 'column-major'; - sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; - st = shape2strides( sh, ord ); + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); - nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Complex128Array([ - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0 - ]); - t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -457,32 +412,28 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d var x; dt = 'float64'; - ord = 'column-major'; - sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = shape2strides( sh, ord ); + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Float64Array([ - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0 - ]); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape('the function applies a nullary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -491,40 +442,28 @@ tape('the function applies a nullary callback to each indexed element of an 10-d var x; dt = 'float64'; - ord = 'column-major'; - sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; - o = strides2offset(sh, st); + ord = 'row-major'; - x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Float64Array( [ - 10.0, - 10.0, - 0.0, - 0.0, - 10.0, - 10.0, - 0.0, - 0.0, - 10.0, - 10.0, - 0.0, - 0.0, - 10.0, - 10.0, - 0.0, - 0.0 - ]); + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape('the function applies a nullary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; + var bsize; var ord; var sh; var st; @@ -533,39 +472,1325 @@ tape('the function applies a nullary callback to each indexed element of an 10-d var x; dt = 'float64'; - ord = 'column-major'; - sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; - st = [ 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ]; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*32, + bsize*16, + -8, + 4, + 4, + 2 + ]; o = strides2offset( sh, st ); - x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); nullary( [ x ], constantFunction( 10.0 ) ); - expected = new Float64Array( [ - 10.0, - 10.0, - 0.0, - 0.0, - 10.0, - 10.0, - 0.0, + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*32, + bsize*32, + -bsize*16, + 8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ]; + st = [ + bsize*32, + bsize*32, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*8, + bsize*8, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( [ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ] ); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( [ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ] ); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0, + 10.0, + 10.0, + 10.0, + 10.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*32, + bsize*16, + -8, + 4, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*32, + bsize*32, + -bsize*16, + 8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ + bsize*64, + bsize*64, + bsize*32, + -bsize*32, + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ]; + st = [ + bsize*32, + bsize*32, + bsize*16, + -bsize*16, + bsize*8, + bsize*8, + -bsize*8, + bsize*8, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-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 ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array([ + 10.0, + 10.0, + 10.0, + 10.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-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 ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ]); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + + x = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -1, -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape('the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset(sh, st); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( [ + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape('the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( [ + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, + 0.0, + 0.0, + 10.0, + 10.0, 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + bsize*4, + bsize*8, + -bsize*8, + bsize*8, + bsize*16, + bsize*16, + -bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + 8, + bsize*16, + bsize*32, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + 4, + 8, + bsize*16, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( 10.0 ) ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array([ 10.0, 10.0, - 0.0, - 0.0, 10.0, 10.0, - 0.0, - 0.0 + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 ]); - t.strictEqual( isSameFloat64Array( x.data, expected ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -577,7 +1802,7 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d dt = 'complex128'; ord = 'column-major'; sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; - st = shape2strides( sh, ord ); + st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ]; o = strides2offset( sh, st ); x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); @@ -722,3 +1947,347 @@ tape( 'the function applies a nullary callback to each indexed element of a 10-d t.end(); }); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + bsize*4, + bsize*8, + -bsize*8, + bsize*8, + bsize*16, + bsize*16, + -bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + bsize*8, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + 8, + bsize*16, + bsize*32, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ + 2, + 4, + 4, + 8, + bsize*16, + bsize*32, + bsize*32, + bsize*64, + bsize*64, + bsize*64 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function applies a nullary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var expected; + var bsize; + var ord; + var sh; + var st; + var dt; + var o; + var x; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + nullary( [ x ], constantFunction( new Complex128( 10.0, 10.0 ) ) ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( x.data, expected ), true, 'returns expected value' ); + + t.end(); +});