From 48d41cc512455c3a784791536170480322b0821e Mon Sep 17 00:00:00 2001 From: headlessNode Date: Wed, 5 Mar 2025 08:22:42 +0500 Subject: [PATCH 1/6] test: add tests upto 3d --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/unary/test/test.0d.js | 89 ++ .../ndarray/base/unary/test/test.1d.js | 116 ++ .../ndarray/base/unary/test/test.2d.js | 1173 +++++++++++++++ .../ndarray/base/unary/test/test.3d.js | 1304 +++++++++++++++++ .../@stdlib/ndarray/base/unary/test/test.js | 2 - 5 files changed, 2682 insertions(+), 2 deletions(-) create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js new file mode 100644 index 000000000000..8e909823fdb6 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js @@ -0,0 +1,89 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 0-dimensional ndarray', function test( t ) { + var expected; + var x; + var y; + + x = scalar2ndarray( 5.0, { + 'dtype': 'float64' + }); + + y = scalar2ndarray( 0.0, { + 'dtype': 'float64' + }); + + unary( [ x, y ], scale ); + + expected = new Float64Array( [ 50.0 ] ); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 0-dimensional ndarray (accessors)', function test( t ) { + var expected; + var x; + var y; + + x = scalar2ndarray( new Complex128( 5.0, 5.0 ), { + 'dtype': 'complex128' + }); + + y = scalar2ndarray( new Complex128( 0.0, 0.0 ), { + 'dtype': 'complex128' + }); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( [ 50.0, 50.0 ] ); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js new file mode 100644 index 000000000000..1ec2d627da80 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js @@ -0,0 +1,116 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ), [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 4 ], [ 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray (empty array)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ), [ 0 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray (accessors)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'complex128', new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ), [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 4 ], [ 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js new file mode 100644 index 000000000000..593ff4e67d8d --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js @@ -0,0 +1,1173 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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 unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function'); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 0 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 1 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 1 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 1 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 1 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ -1, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ 2, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ -2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ -1, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2 ]; + st = [ 2, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 2-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2 ]; + st = [ -2, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js new file mode 100644 index 000000000000..081cbdb4af5e --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js @@ -0,0 +1,1304 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var oneTo = require( '@stdlib/array/one-to' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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 blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var dfill = require( '@stdlib/blas/ext/base/dfill' ); +var gfill = require( '@stdlib/blas/ext/base/gfill' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 2 ]; + st = [ -4, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 3, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 40.0, + 50.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -3, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 40.0, + 50.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2 ]; + st = [ bsize*8, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2, 2 ]; + st = [ -4, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 3, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -3, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2 ]; + st = [ -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2 ]; + st = [ bsize*8, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 2 ]; + st = [ -1, -2, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 1, 2, 3 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 40.0, + 50.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -1, -2, 3 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 40.0, + 50.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 1 ]; + st = [ -2, bsize*4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2, 2 ]; + st = [ -1, -2, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 1, 2, 3 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -1, -2, 3 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1 ]; + st = [ 2, -4, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a nullary callback to each indexed element of a 3-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2 ]; + st = [ 2, -4, 4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js index 8cfddde2e3cd..e5042c7f017f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js @@ -31,5 +31,3 @@ tape( 'main export is a function', function test( t ) { t.strictEqual( typeof unary, 'function', 'main export is a function' ); t.end(); }); - -// FIXME: add tests From 276f46f7f9f78ecfae96a10e1d0a2c9d527f2b34 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Wed, 5 Mar 2025 16:30:04 +0500 Subject: [PATCH 2/6] test: add 4d, 5d, and 6d tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/unary/test/test.4d.js | 1468 +++++++++++++ .../ndarray/base/unary/test/test.5d.js | 1695 +++++++++++++++ .../ndarray/base/unary/test/test.6d.js | 1844 +++++++++++++++++ 3 files changed, 5007 insertions(+) create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js new file mode 100644 index 000000000000..550d45f273ca --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js @@ -0,0 +1,1468 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +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 unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 2, 1, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, -2, -1, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ bsize*8, bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ bsize*8, bsize*4, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 2, 1, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, -2, -1, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ bsize*8, bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ bsize*8, bsize*4, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return new Complex128( x.re*10.0, x.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, -2, -4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ 2, 2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ 2, 2, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 1, bsize*2, 1, 2 ]; + st = [ 2, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, 2, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*4, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ 1, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 4-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*4 ]; + st = [ 2, 4, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js new file mode 100644 index 000000000000..971925c4c28d --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js @@ -0,0 +1,1695 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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 unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2, 2 ]; + st = [ -8, -4, -4, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0, + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, 2, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, -2, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, -4, 4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( x ) { + return x * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, 2, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ 8, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, -4, 4, -4, -2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2, 2 ]; + st = [ -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0, + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, -2, -4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ -2, 4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, -2, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1 ]; + st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ -2, 4, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ -2, -4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 5-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ 2, 4, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js new file mode 100644 index 000000000000..3cd60c1f708e --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js @@ -0,0 +1,1844 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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/unary-tiling-block-size' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 8, -8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ bsize*8, -4, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, -bsize*8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + 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, ones( numel( sh )*2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, -4, -4, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 8, -8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ bsize*8, -4, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, -bsize*8, -4, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 1, -1, 1, -2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 100.0, + 110.0, + 120.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 1 ]; + st = [ 2, 4, 4, -4, 8, -bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z*10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, -2, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 1 ]; + st = [ 2, 4, 4, -4, 8, -bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 6-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2 ]; + st = [ 2, 4, 4, -8, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); From ff48ed315c90128b73072a177d528e26edc8f583 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Thu, 6 Mar 2025 10:39:28 +0500 Subject: [PATCH 3/6] test: add tests upto nd --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/unary/test/test.10d.js | 2604 +++++++++++++++++ .../ndarray/base/unary/test/test.2d.js | 2 +- .../ndarray/base/unary/test/test.3d.js | 2 +- .../ndarray/base/unary/test/test.4d.js | 2 +- .../ndarray/base/unary/test/test.5d.js | 2 +- .../ndarray/base/unary/test/test.7d.js | 2048 +++++++++++++ .../ndarray/base/unary/test/test.8d.js | 2166 ++++++++++++++ .../ndarray/base/unary/test/test.9d.js | 2388 +++++++++++++++ .../ndarray/base/unary/test/test.nd.js | 804 +++++ 9 files changed, 10014 insertions(+), 4 deletions(-) create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js new file mode 100644 index 000000000000..e135b49da563 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js @@ -0,0 +1,2604 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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/unary-tiling-block-size' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 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' ); + y = 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' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 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' ); + y = 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' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1, 1 ]; + st = [ -1, -1, -1, -1, -1, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 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; + var y; + + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + 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, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 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; + var y; + + 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, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js index 593ff4e67d8d..3e36e472752f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js @@ -35,7 +35,7 @@ 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 blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' ); var unary = require( './../lib' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js index 081cbdb4af5e..af385a133a94 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js @@ -33,7 +33,7 @@ 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 blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' ); +var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' ); var dfill = require( '@stdlib/blas/ext/base/dfill' ); var gfill = require( '@stdlib/blas/ext/base/gfill' ); var unary = require( './../lib' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js index 550d45f273ca..23ff4607efb7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js @@ -35,7 +35,7 @@ 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 blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' ); var unary = require( './../lib' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js index 971925c4c28d..dae7ce50169c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js @@ -35,7 +35,7 @@ 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 blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' ); var unary = require( './../lib' ); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js new file mode 100644 index 000000000000..487b55a33e56 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js @@ -0,0 +1,2048 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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/unary-tiling-block-size' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re * 10.0, z.im * 10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -16, 16, -16, 8, -4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 1, 2 ]; + st = [ bsize*16, -8, 8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -8, -8, -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 150.0, + 0.0, + 160.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -16, 16, -16, -8, 4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 16, -16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ bsize*16, -8, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ]; + st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0, + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 0.0, + 30.0, + 0.0, + 50.0, + 0.0, + 70.0, + 0.0, + 90.0, + 0.0, + 110.0, + 0.0, + 130.0, + 0.0, + 150.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, -1, 2, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 0.0, + 30.0, + 0.0, + 50.0, + 0.0, + 70.0, + 0.0, + 90.0, + 0.0, + 110.0, + 0.0, + 130.0, + 0.0, + 150.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, bsize*8, -bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 2, 1, 2, 1 ]; + st = [ 2, -4, bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 1, 2 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 110.0, + 0.0, + 120.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 150.0, + 0.0, + 160.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 2, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 0.0, + 0.0, + 30.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0, + 70.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 0.0, + 0.0, + 110.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 0.0, + 0.0, + 150.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -1, 1, -1, -2, 4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 0.0, + 0.0, + 30.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 0.0, + 0.0, + 70.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 0.0, + 0.0, + 110.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 0.0, + 0.0, + 150.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ]; + st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ]; + st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ]; + st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ]; + st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of a 7-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ]; + st = [ 2, -4, -4, 8, 8, 16, 16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js new file mode 100644 index 000000000000..51085edb5f6b --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js @@ -0,0 +1,2166 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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/unary-tiling-block-size' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ]; + st = [ 32, -16, 8, -8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ]; + st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ]; + st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ]; + st = [ + -bsize*16, + -bsize*16, + bsize*8, + -bsize*8, + -bsize*8, + bsize*4, + -bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, -16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ]; + st = [ 32, 16, 8, -8, -8, 4, 4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ]; + st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ]; + st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ]; + st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ]; + st = [ + -bsize*16, + -bsize*16, + bsize*8, + -bsize*8, + -bsize*8, + bsize*4, + -bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = [ -1, -1, -1, -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset(sh, st); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, -1, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = [ -1, -1, -1, -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -1, 1, -1, 1, 1, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ]; + st = [ 2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ]; + st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ]; + st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 8-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js new file mode 100644 index 000000000000..555501dd8e6b --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js @@ -0,0 +1,2388 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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/unary-tiling-block-size' ); +var unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + 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, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ + bsize*64, + -bsize*64, + -bsize*32, + bsize*32, + bsize*32, + -bsize*16, + 8, + -4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ]; + st = [ + -bsize*32, + -bsize*32, + -bsize*16, + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ]; + st = [ + -bsize*32, + -bsize*32, + -bsize*16, + bsize*16, + bsize*8, + -bsize*8, + bsize*8, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ + bsize*64, + -bsize*64, + -bsize*32, + bsize*32, + bsize*32, + -bsize*16, + 8, + -4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ]; + st = [ + -bsize*32, + -bsize*32, + -bsize*16, + bsize*16, + bsize*16, + -bsize*16, + bsize*8, + 4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ]; + st = [ + -bsize*32, + -bsize*32, + -bsize*16, + bsize*16, + bsize*8, + -bsize*8, + bsize*8, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, empty)', function test( t ) { + var expected; + var x; + var y; + + x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2, 1, 1 ]; + st = [ -1, -1, -1, -1, -2, -4, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset(sh, st); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ + 2, + bsize*4, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ]; + st = [ + 2, + 4, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ]; + st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 10.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = [ -1, -1, -1, -1, -1, -2, -4, -4, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -1, -1, 1, -1, 1, 1, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ]; + st = [ + 2, + bsize*4, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*32, + bsize*32, + bsize*32 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ]; + st = [ + 2, + 4, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ]; + st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ]; + st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ]; + st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ]; + st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ]; + st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an 9-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; + var y; + + dt = 'complex128'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ]; + st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array( x.length*2 ); + gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js new file mode 100644 index 000000000000..754e37fe2961 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js @@ -0,0 +1,804 @@ +/** +* @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 isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var oneTo = require( '@stdlib/array/one-to' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +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 unary = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof unary, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-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; + var y; + + dt = 'complex128'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, contiguous)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 30.0, + 40.0, + 50.0, + 60.0, + 70.0, + 80.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an n-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset(sh, st); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape('the function applies a unary callback to each indexed element of an n-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; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Float64Array([ + 10.0, + 20.0, + 0.0, + 0.0, + 50.0, + 60.0, + 0.0, + 0.0, + 90.0, + 100.0, + 0.0, + 0.0, + 130.0, + 140.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return z * 10.0; + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 30.0, + 0.0, + 40.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 70.0, + 0.0, + 80.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); + +tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var expected; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'complex128'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 1, 1, 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ]; + o = strides2offset( sh, st ); + + x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); + + unary( [ x, y ], scale ); + + expected = new Complex128Array([ + 10.0, + 0.0, + 20.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 50.0, + 0.0, + 60.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 90.0, + 0.0, + 100.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 130.0, + 0.0, + 140.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + t.end(); + + function scale( z ) { + return new Complex128( z.re*10.0, z.im*10.0 ); + } +}); From 8a3d4d67fadc35247ed5c59fa6ea0d4f5394dedd Mon Sep 17 00:00:00 2001 From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> Date: Thu, 6 Mar 2025 08:03:09 +0000 Subject: [PATCH 4/6] test: add edge cases --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/ndarray/base/unary/test/test.js | 104 ++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js index e5042c7f017f..2dd705e946d8 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js @@ -21,6 +21,12 @@ // MODULES // var tape = require( 'tape' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var zeros = require( '@stdlib/array/zeros' ); +var ones = require( '@stdlib/array/ones' ); +var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); +var numel = require( '@stdlib/ndarray/base/numel' ); var unary = require( './../lib' ); @@ -31,3 +37,101 @@ tape( 'main export is a function', function test( t ) { t.strictEqual( typeof unary, 'function', 'main export is a function' ); t.end(); }); + +tape( 'the function throws an error if provided input and output ndarrays which do not have the same number of dimensions', function test( t ) { + var shapes; + var i; + + shapes = [ + [ [ 4, 2, 1 ], [ 4, 2 ] ], + [ [ 2, 2 ], [ 2, 2, 2 ] ], + [ [ 1, 1, 1, 1 ], [ 1, 1, 1 ] ], + [ [ 2, 2, 1, 2 ], [ 2, 1, 2 ] ], + [ [ 1, 1, 4, 2, 2, 2 ], [ 10, 2 ] ], + [ [ 1, 1, 1, 1 ], [ 1, 1, 1 ] ] + ]; + + for ( i = 0; i < shapes.length; i++ ) { + t.throws( badValue( shapes[i][0], shapes[i][1] ), Error, 'throws an error when input shape is ' + shapes[i][0] + ' and output shape is ' + shapes[i][1] ); + } + t.end(); + + function scale( z ) { + return z * 10.0; + } + + function badValue( sh1, sh2 ) { + return function badValue() { + var dtype; + var ord; + var st1; + var st2; + var o1; + var o2; + var x; + var y; + + ord = 'row-major'; + dtype = 'float64'; + + st1 = shape2strides( sh1, ord ); + st2 = shape2strides( sh2, ord ); + o1 = strides2offset( sh1, st1 ); + o2 = strides2offset( sh2, st2 ); + + x = ndarray( dtype, ones( numel( sh1 ), dtype ), sh1, st1, o1, ord ); + y = ndarray( dtype, zeros( numel( sh2 ), dtype ), sh2, st2, o2, ord ); + + unary( [ x, y ], scale ); + }; + } +}); + +tape( 'the function throws an error if provided input and output ndarrays which do not have the same shape', function test( t ) { + var shapes; + var i; + + shapes = [ + [ [ 4, 2, 1 ], [ 4, 2, 2 ] ], + [ [ 3, 3 ], [ 2, 2 ] ], + [ [ 5, 5, 5 ], [ 5, 5, 4 ] ], + [ [ 1, 1, 1 ], [ 2, 2, 2 ] ], + [ [ 1, 4, 1, 2, 2 ], [ 3, 8 ] ], + [ [ 10, 2, 1 ], [ 1, 2, 10 ] ] + ]; + + for ( i = 0; i < shapes.length; i++ ) { + t.throws( badValue( shapes[i][0], shapes[i][1] ), Error, 'throws an error when input shape is ' + shapes[i][0] + ' and output shape is ' + shapes[i][1] ); + } + t.end(); + + function scale( z ) { + return z * 10.0; + } + + function badValue( sh1, sh2 ) { + return function badValue() { + var dtype; + var ord; + var st1; + var st2; + var o1; + var o2; + var x; + var y; + + ord = 'row-major'; + dtype = 'float64'; + + st1 = shape2strides( sh1, ord ); + st2 = shape2strides( sh2, ord ); + o1 = strides2offset( sh1, st1 ); + o2 = strides2offset( sh2, st2 ); + + x = ndarray( dtype, ones( numel( sh1 ), dtype ), sh1, st1, o1, ord ); + y = ndarray( dtype, zeros( numel( sh2 ), dtype ), sh2, st2, o2, ord ); + + unary( [ x, y ], scale ); + }; + } +}); From 185a3bc6b7b191d919d9f9b338ace33b8b311cd6 Mon Sep 17 00:00:00 2001 From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> Date: Thu, 6 Mar 2025 10:49:11 +0000 Subject: [PATCH 5/6] chore: cleanup --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/unary/test/test.0d.js | 2 - .../ndarray/base/unary/test/test.10d.js | 124 +++++++++--------- .../ndarray/base/unary/test/test.9d.js | 116 ++++++++-------- 3 files changed, 120 insertions(+), 122 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js index 8e909823fdb6..3e861a52bcbe 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js @@ -55,7 +55,6 @@ tape( 'the function applies a unary callback to each indexed element of a 0-dime expected = new Float64Array( [ 50.0 ] ); t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); - t.end(); function scale( x ) { @@ -80,7 +79,6 @@ tape( 'the function applies a unary callback to each indexed element of a 0-dime expected = new Complex128Array( [ 50.0, 50.0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); - t.end(); function scale( z ) { diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js index e135b49da563..9f745710bb21 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js @@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { var expected; var ord; var sh; @@ -82,7 +82,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { var expected; var ord; var sh; @@ -121,7 +121,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, empty)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, empty)', function test( t ) { var expected; var x; var y; @@ -145,7 +145,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous)', function test( t ) { var expected; var ord; var sh; @@ -184,7 +184,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -223,7 +223,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function applies a unary 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; @@ -270,7 +270,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function applies a unary 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; @@ -317,7 +317,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -352,7 +352,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -387,7 +387,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -422,7 +422,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -457,7 +457,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -492,7 +492,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -527,7 +527,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -573,7 +573,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -619,7 +619,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -665,7 +665,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -711,7 +711,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { var expected; var ord; var sh; @@ -758,7 +758,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) { +tape( 'the function applies a unary 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; @@ -805,7 +805,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -868,7 +868,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -931,7 +931,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -966,7 +966,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1001,7 +1001,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1036,7 +1036,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1071,7 +1071,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1106,7 +1106,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1141,7 +1141,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1187,7 +1187,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1233,7 +1233,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1279,7 +1279,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1325,7 +1325,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { var expected; var ord; var sh; @@ -1360,7 +1360,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { var expected; var ord; var sh; @@ -1399,7 +1399,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, empty)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, empty)', function test( t ) { var expected; var x; var y; @@ -1423,7 +1423,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous)', function test( t ) { var expected; var ord; var sh; @@ -1462,7 +1462,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -1501,7 +1501,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape('the function applies a unary 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 unary 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; @@ -1548,7 +1548,7 @@ tape('the function applies a unary callback to each indexed element of an 10-dim } }); -tape('the function applies a unary 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 unary 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; @@ -1595,7 +1595,7 @@ tape('the function applies a unary callback to each indexed element of an 10-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1641,7 +1641,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1687,7 +1687,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1733,7 +1733,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1779,7 +1779,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1814,7 +1814,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1849,7 +1849,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1884,7 +1884,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1919,7 +1919,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1954,7 +1954,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary 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; @@ -1989,7 +1989,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { var expected; var ord; var sh; @@ -2036,7 +2036,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2083,7 +2083,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -2146,7 +2146,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -2209,7 +2209,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2255,7 +2255,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2301,7 +2301,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2347,7 +2347,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2393,7 +2393,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2428,7 +2428,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2463,7 +2463,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2498,7 +2498,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2533,7 +2533,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; @@ -2568,7 +2568,7 @@ tape( 'the function applies a unary callback to each indexed element of an 10-di } }); -tape( 'the function applies a unary callback to each indexed element of an 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary 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; diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js index 555501dd8e6b..b64799a28448 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js @@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, singleton dimensions)', function test( t ) { var expected; var ord; var sh; @@ -82,7 +82,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) { var expected; var ord; var sh; @@ -121,7 +121,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, empty)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, empty)', function test( t ) { var expected; var x; var y; @@ -145,7 +145,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous)', function test( t ) { var expected; var ord; var sh; @@ -184,7 +184,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -223,7 +223,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { var expected; var ord; var sh; @@ -270,7 +270,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { var expected; var ord; var sh; @@ -317,7 +317,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -352,7 +352,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -387,7 +387,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -422,7 +422,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -457,7 +457,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -492,7 +492,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -527,7 +527,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -572,7 +572,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -617,7 +617,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -662,7 +662,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) { var expected; var ord; var sh; @@ -709,7 +709,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -756,7 +756,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -819,7 +819,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -882,7 +882,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -917,7 +917,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -952,7 +952,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -987,7 +987,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1022,7 +1022,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1057,7 +1057,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1092,7 +1092,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1137,7 +1137,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1182,7 +1182,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -1227,7 +1227,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, singleton dimensions)', function test( t ) { var expected; var ord; var sh; @@ -1262,7 +1262,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) { var expected; var ord; var sh; @@ -1301,7 +1301,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, empty)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, empty)', function test( t ) { var expected; var x; var y; @@ -1325,7 +1325,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous)', function test( t ) { var expected; var ord; var sh; @@ -1364,7 +1364,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -1403,7 +1403,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape('the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { +tape('the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { var expected; var ord; var sh; @@ -1450,7 +1450,7 @@ tape('the function applies a unary callback to each indexed element of an 9-dime } }); -tape('the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { +tape('the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { var expected; var ord; var sh; @@ -1497,7 +1497,7 @@ tape('the function applies a unary callback to each indexed element of an 9-dime } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1542,7 +1542,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1587,7 +1587,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1622,7 +1622,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1657,7 +1657,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1692,7 +1692,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1727,7 +1727,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1762,7 +1762,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1797,7 +1797,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) { var expected; var bsize; var ord; @@ -1832,7 +1832,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) { var expected; var ord; var sh; @@ -1879,7 +1879,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) { var expected; var ord; var sh; @@ -1926,7 +1926,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -1989,7 +1989,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { var expected; var ord; var sh; @@ -2052,7 +2052,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2097,7 +2097,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2142,7 +2142,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2177,7 +2177,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2212,7 +2212,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2247,7 +2247,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2282,7 +2282,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2317,7 +2317,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; @@ -2352,7 +2352,7 @@ tape( 'the function applies a unary callback to each indexed element of an 9-dim } }); -tape( 'the function applies a unary callback to each indexed element of an 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { +tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { var expected; var bsize; var ord; From 8f84e0d16a35880e6d973d197941aa0f2dabe64d Mon Sep 17 00:00:00 2001 From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com> Date: Tue, 1 Apr 2025 10:56:37 +0000 Subject: [PATCH 6/6] refactor: apply code review suggestions --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/unary/test/test.0d.js | 4 +- .../ndarray/base/unary/test/test.10d.js | 346 +++++++++--------- .../ndarray/base/unary/test/test.1d.js | 4 +- .../ndarray/base/unary/test/test.2d.js | 162 ++++---- .../ndarray/base/unary/test/test.3d.js | 182 ++++----- .../ndarray/base/unary/test/test.4d.js | 204 ++++++----- .../ndarray/base/unary/test/test.5d.js | 278 +++++++------- .../ndarray/base/unary/test/test.6d.js | 295 ++++++++------- .../ndarray/base/unary/test/test.7d.js | 342 ++++++++--------- .../ndarray/base/unary/test/test.8d.js | 322 ++++++++-------- .../ndarray/base/unary/test/test.9d.js | 334 ++++++++--------- .../ndarray/base/unary/test/test.nd.js | 186 +++++----- 12 files changed, 1349 insertions(+), 1310 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js index 3e861a52bcbe..a0d01e23dc0f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js @@ -26,6 +26,8 @@ var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Float64Array = require( '@stdlib/array/float64' ); 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 unary = require( './../lib' ); @@ -82,6 +84,6 @@ tape( 'the function applies a unary callback to each indexed element of a 0-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js index 9f745710bb21..df82e8fc5d1f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -727,34 +729,34 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -774,34 +776,34 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -821,40 +823,40 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -864,7 +866,7 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -884,41 +886,41 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -927,7 +929,7 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -950,19 +952,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -985,19 +987,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1020,19 +1022,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1055,19 +1057,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1090,19 +1092,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1125,19 +1127,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1171,19 +1173,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1217,19 +1219,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1263,19 +1265,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1309,19 +1311,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 9 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1376,26 +1378,26 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2005,34 +2007,34 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2052,34 +2054,34 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2099,40 +2101,40 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -2142,7 +2144,7 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2162,41 +2164,41 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ -1, -1, -1, 1, -1, 1, 1, -4, -8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -2205,7 +2207,7 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2239,19 +2241,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2285,19 +2287,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2331,19 +2333,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2377,19 +2379,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2412,19 +2414,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2447,19 +2449,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2482,19 +2484,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2517,19 +2519,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2552,19 +2554,19 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2587,18 +2589,18 @@ tape( 'the function applies a unary callback to each indexed element of a 10-dim st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js index 1ec2d627da80..0c2eeba53b30 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js @@ -27,6 +27,8 @@ var Complex128Array = require( '@stdlib/array/complex128' ); var Float64Array = require( '@stdlib/array/float64' ); var zeros = require( '@stdlib/array/zeros' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var unary = require( './../lib' ); @@ -111,6 +113,6 @@ tape( 'the function applies a unary callback to each indexed element of a 1-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js index 3e36e472752f..e19ae6da0070 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -388,26 +390,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -427,26 +429,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -466,24 +468,24 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ 4, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -493,7 +495,7 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -513,24 +515,24 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ 4, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -540,7 +542,7 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -563,19 +565,19 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 1 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -598,19 +600,19 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ bsize*4, -2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 1 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -665,26 +667,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -946,26 +948,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -985,26 +987,26 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ -1, -2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1024,24 +1026,24 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ 1, 4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -1051,7 +1053,7 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1071,24 +1073,24 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ 1, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -1098,7 +1100,7 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1121,19 +1123,19 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ 2, -bsize*4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1156,18 +1158,18 @@ tape( 'the function applies a unary callback to each indexed element of a 2-dime st = [ -2, 4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js index af385a133a94..35100fbc94e5 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var ones = require( '@stdlib/array/ones' ); var oneTo = require( '@stdlib/array/one-to' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -414,26 +416,26 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -453,34 +455,34 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -4, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -500,22 +502,22 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ 3, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, + 30.0, 40.0, 0.0, - 50.0, 0.0, + 70.0, + 80.0, + 90.0, + 100.0, 0.0, 0.0 ]); @@ -523,7 +525,7 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -543,22 +545,22 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -3, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, + 30.0, 40.0, 0.0, - 50.0, 0.0, + 70.0, + 80.0, + 90.0, + 100.0, 0.0, 0.0 ]); @@ -566,7 +568,7 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -589,19 +591,19 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -624,19 +626,19 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -bsize*8, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -659,19 +661,19 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ bsize*8, bsize*4, -2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 2 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -726,26 +728,26 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1042,26 +1044,26 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1081,34 +1083,34 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -1, -2, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1128,22 +1130,22 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ 1, 2, 3 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, + 30.0, 40.0, 0.0, - 50.0, 0.0, + 70.0, + 80.0, + 90.0, + 100.0, 0.0, 0.0 ]); @@ -1151,7 +1153,7 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1171,22 +1173,22 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ -1, -2, 3 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, + 30.0, 40.0, 0.0, - 50.0, 0.0, + 70.0, + 80.0, + 90.0, + 100.0, 0.0, 0.0 ]); @@ -1194,7 +1196,7 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1217,19 +1219,19 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ 2, -4, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1252,19 +1254,19 @@ tape( 'the function applies a unary callback to each indexed element of a 3-dime st = [ 2, -4, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1287,18 +1289,18 @@ tape( 'the function applies a nullary callback to each indexed element of a 3-di st = [ 2, -4, 4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js index 23ff4607efb7..4f3f575917df 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js @@ -27,6 +27,8 @@ var Complex128Array = require( '@stdlib/array/complex128' ); var Float64Array = require( '@stdlib/array/float64' ); var zeros = require( '@stdlib/array/zeros' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var ndarray = require( '@stdlib/ndarray/ctor' ); @@ -414,26 +416,26 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -453,26 +455,26 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -492,34 +494,34 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -539,24 +541,24 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 4, 2, 1, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -566,7 +568,7 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -586,24 +588,24 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 4, -2, -1, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -613,7 +615,7 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -636,19 +638,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ -4, -4, 2, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -671,19 +673,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ -bsize*8, -4, 2, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -706,19 +708,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ bsize*8, bsize*4, -2, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -741,19 +743,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ bsize*8, bsize*4, bsize*4, -2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 3 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -808,26 +810,26 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); - function scale( x ) { - return new Complex128( x.re*10.0, x.im*10.0 ); + function scale( z ) { + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1163,26 +1165,26 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1202,34 +1204,34 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ -1, -2, -4, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1249,24 +1251,24 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 1, 2, 4, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -1276,7 +1278,7 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1296,24 +1298,24 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 1, 2, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 90.0, + 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, @@ -1323,7 +1325,7 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1346,19 +1348,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 2, -bsize*4, -bsize*4, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1381,19 +1383,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 1, 2, -bsize*4, -bsize*4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1416,19 +1418,19 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 2, 4, -4, -bsize*4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1451,18 +1453,18 @@ tape( 'the function applies a unary callback to each indexed element of a 4-dime st = [ 2, 4, -4, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js index dae7ce50169c..0369c5715fff 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -508,34 +510,34 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -555,34 +557,34 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -4, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -602,19 +604,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 8, 4, 2, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -623,21 +626,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime 0.0, 0.0, 0.0, - 0.0, - 90.0, - 0.0, - 100.0, - 0.0, - 110.0, - 0.0, - 120.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -657,19 +659,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 8, 4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -678,21 +681,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime 0.0, 0.0, 0.0, - 0.0, - 90.0, - 0.0, - 100.0, - 0.0, - 110.0, - 0.0, - 120.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -715,19 +717,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 8, -8, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -750,19 +752,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ bsize*8, -4, 4, -4, -2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -785,19 +787,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ bsize*8, bsize*8, -4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -820,19 +822,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -855,19 +857,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 4 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -922,26 +924,26 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1332,34 +1334,34 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1379,34 +1381,34 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -1, -2, -2, -4, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1426,19 +1428,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 1, 2, 2, 4, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -1447,21 +1450,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime 0.0, 0.0, 0.0, - 0.0, - 90.0, - 0.0, - 100.0, - 0.0, - 110.0, - 0.0, - 120.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1481,19 +1483,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 1, 2, -2, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -1502,21 +1505,20 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime 0.0, 0.0, 0.0, - 0.0, - 90.0, - 0.0, - 100.0, - 0.0, - 110.0, - 0.0, - 120.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1539,19 +1541,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1573,19 +1575,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1608,19 +1610,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -2, 4, -4, bsize*8, bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1643,19 +1645,19 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ -2, -4, -4, 4, bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1678,18 +1680,18 @@ tape( 'the function applies a unary callback to each indexed element of a 5-dime st = [ 2, 4, -4, 8, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js index 3cd60c1f708e..137c95de38c5 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -543,34 +545,34 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -590,34 +592,34 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ -8, -8, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -637,41 +639,41 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 16, 16, 8, 4, 4, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -680,7 +682,7 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -700,40 +702,40 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 16, 16, 8, -4, -4, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -743,7 +745,7 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -766,19 +768,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 8, -8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -801,19 +803,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ bsize*8, -4, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -836,19 +838,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ bsize*8, -bsize*8, -4, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -871,19 +873,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -906,19 +908,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ bsize*8, -bsize*8, -bsize*8, bsize*8, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -941,19 +943,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 5 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1008,26 +1010,26 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1445,34 +1447,34 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1492,34 +1494,34 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ -1, -1, -1, -2, -4, -4 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1539,19 +1541,20 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 1, 1, 1, 2, 4, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); - y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -1560,21 +1563,28 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0, + 0.0, + 0.0, + 0.0, 0.0, - 90.0, 0.0, - 100.0, 0.0, - 110.0, 0.0, - 120.0, 0.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1594,19 +1604,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 1, 1, 1, -2, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord ); - y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord ); - + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); + y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, + 50.0, + 60.0, + 70.0, + 80.0, 0.0, 0.0, 0.0, @@ -1615,21 +1625,28 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0, + 0.0, + 0.0, + 0.0, 0.0, - 90.0, 0.0, - 100.0, 0.0, - 110.0, 0.0, - 120.0, 0.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1652,19 +1669,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1687,19 +1704,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1722,19 +1739,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1757,19 +1774,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1792,19 +1809,19 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, 4, 4, -4, 8, -bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1827,18 +1844,18 @@ tape( 'the function applies a unary callback to each indexed element of a 6-dime st = [ 2, 4, 4, -8, 8, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js index 487b55a33e56..8b0e3c096bb7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re * 10.0, z.im * 10.0 ); + return new Complex128( real(z) * 10.0, imag(z) * 10.0 ); } }); @@ -578,34 +580,34 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -625,50 +627,50 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ -8, -8, -4, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0, 90.0, - 0.0, 100.0, - 0.0, 110.0, - 0.0, 120.0, - 0.0, 130.0, - 0.0, 140.0, - 0.0, 150.0, - 0.0, 160.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0, + 250.0, + 260.0, + 270.0, + 280.0, + 290.0, + 300.0, + 310.0, + 320.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -688,41 +690,41 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -731,7 +733,7 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -751,41 +753,41 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ -16, 16, -16, -8, 4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -794,7 +796,7 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -817,19 +819,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 16, -16, 8, 8, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -852,19 +854,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -8, 8, 8, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -887,19 +889,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -922,19 +924,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -957,19 +959,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -992,19 +994,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1027,19 +1029,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 6 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1094,26 +1096,26 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1582,34 +1584,34 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1629,50 +1631,50 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ -1, -2, -2, -4, -4, -8, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0, 90.0, - 0.0, 100.0, - 0.0, 110.0, - 0.0, 120.0, - 0.0, 130.0, - 0.0, 140.0, - 0.0, 150.0, - 0.0, 160.0, - 0.0 + 170.0, + 180.0, + 190.0, + 200.0, + 210.0, + 220.0, + 230.0, + 240.0, + 250.0, + 260.0, + 270.0, + 280.0, + 290.0, + 300.0, + 310.0, + 320.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1692,42 +1694,42 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 1, 1, 1, 2, 4, 8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, - 0.0, - 0.0, - 30.0, - 0.0, + 20.0, 0.0, 0.0, 50.0, - 0.0, - 0.0, - 0.0, - 70.0, - 0.0, + 60.0, 0.0, 0.0, 90.0, + 100.0, 0.0, 0.0, + 130.0, + 140.0, 0.0, - 110.0, 0.0, + 170.0, + 180.0, 0.0, 0.0, - 130.0, + 210.0, + 220.0, 0.0, 0.0, + 250.0, + 260.0, 0.0, - 150.0, 0.0, + 290.0, + 300.0, 0.0, 0.0 ]); @@ -1735,7 +1737,7 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1755,42 +1757,42 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ -1, 1, -1, -2, 4, -8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, - 0.0, - 0.0, - 30.0, - 0.0, + 20.0, 0.0, 0.0, 50.0, - 0.0, - 0.0, - 0.0, - 70.0, - 0.0, + 60.0, 0.0, 0.0, 90.0, + 100.0, 0.0, 0.0, + 130.0, + 140.0, 0.0, - 110.0, 0.0, + 170.0, + 180.0, 0.0, 0.0, - 130.0, + 210.0, + 220.0, 0.0, 0.0, + 250.0, + 260.0, 0.0, - 150.0, 0.0, + 290.0, + 300.0, 0.0, 0.0 ]); @@ -1798,7 +1800,7 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1821,19 +1823,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1856,19 +1858,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1891,19 +1893,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1926,19 +1928,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1961,19 +1963,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1996,19 +1998,19 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -4, 8, 8, 8, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2031,18 +2033,18 @@ tape( 'the function applies a unary callback to each indexed element of a 7-dime st = [ 2, -4, -4, 8, 8, 16, 16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js index 51085edb5f6b..e615e4a405ef 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -622,34 +624,34 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -669,34 +671,34 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -8, -8, -8, -8, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -716,40 +718,40 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 16, 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -759,7 +761,7 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -779,41 +781,41 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 16, 16, -16, 16, -8, -4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -822,7 +824,7 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -845,19 +847,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 32, 16, 8, -8, -8, 4, 4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -880,19 +882,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -915,19 +917,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -950,19 +952,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -985,19 +987,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1020,19 +1022,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1055,19 +1057,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1099,19 +1101,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 7 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1166,26 +1168,26 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1681,34 +1683,34 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1728,34 +1730,34 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -1, -1, -1, -1, -2, -4, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1775,40 +1777,40 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 1, 1, 1, 1, 1, 4, 8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -1818,7 +1820,7 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1838,41 +1840,41 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ -1, 1, -1, 1, 1, -4, -8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, + 0.0, 0.0, 0.0, 0.0 @@ -1881,7 +1883,7 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1904,19 +1906,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1939,19 +1941,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1974,19 +1976,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2009,19 +2011,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2044,19 +2046,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2079,19 +2081,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2114,19 +2116,19 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2149,18 +2151,18 @@ tape( 'the function applies a unary callback to each indexed element of an 8-dim st = [ 2, 4, 4, 8, 8, 8, 16, 32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js index b64799a28448..45947ff99d58 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js @@ -29,6 +29,8 @@ var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var ones = require( '@stdlib/array/ones' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -98,26 +100,26 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -678,34 +680,34 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -725,34 +727,34 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -772,40 +774,40 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -815,7 +817,7 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -835,40 +837,40 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -878,7 +880,7 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -901,19 +903,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -936,19 +938,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -971,19 +973,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1006,19 +1008,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1041,19 +1043,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1076,19 +1078,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1121,19 +1123,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1166,19 +1168,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1211,19 +1213,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 8 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1278,26 +1280,26 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1848,34 +1850,34 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1895,34 +1897,34 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ -1, -1, -1, -1, -1, -2, -4, -4, -8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -1942,40 +1944,40 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -1985,7 +1987,7 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2005,40 +2007,40 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ -1, -1, 1, -1, 1, 1, -4, -8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -2048,7 +2050,7 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2081,19 +2083,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2126,19 +2128,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2161,19 +2163,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2196,19 +2198,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2231,19 +2233,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2266,19 +2268,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2301,19 +2303,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2336,19 +2338,19 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -2371,18 +2373,18 @@ tape( 'the function applies a unary callback to each indexed element of a 9-dime st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ]; o = strides2offset( sh, st ); - x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array( x.length*2 ); - gfill( x.length, new Complex128( 10.0, 0.0 ), expected, st[ 0 ] ); + gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] ); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js index 754e37fe2961..a550a886d9e7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js +++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js @@ -28,6 +28,8 @@ var Float64Array = require( '@stdlib/array/float64' ); var zeros = require( '@stdlib/array/zeros' ); var oneTo = require( '@stdlib/array/one-to' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); var ndarray = require( '@stdlib/ndarray/ctor' ); var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); var strides2offset = require( '@stdlib/ndarray/base/strides2offset' ); @@ -94,26 +96,26 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -266,34 +268,34 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -313,40 +315,40 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -356,7 +358,7 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -376,40 +378,40 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = [ 16, 16, 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -419,7 +421,7 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -474,26 +476,26 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0 + 50.0, + 60.0, + 70.0, + 80.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -646,34 +648,34 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = shape2strides( sh, ord ); o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, 30.0, - 0.0, 40.0, - 0.0, 50.0, - 0.0, 60.0, - 0.0, 70.0, - 0.0, 80.0, - 0.0 + 90.0, + 100.0, + 110.0, + 120.0, + 130.0, + 140.0, + 150.0, + 160.0 ]); t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -693,40 +695,40 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -736,7 +738,7 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } }); @@ -756,40 +758,40 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim st = [ 1, 1, 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ]; o = strides2offset( sh, st ); - x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord ); + x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord ); y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord ); unary( [ x, y ], scale ); expected = new Complex128Array([ 10.0, - 0.0, 20.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 50.0, - 0.0, - 60.0, - 0.0, + 30.0, + 40.0, 0.0, 0.0, 0.0, 0.0, 90.0, - 0.0, 100.0, + 110.0, + 120.0, 0.0, 0.0, 0.0, 0.0, + 170.0, + 180.0, + 190.0, + 200.0, + 0.0, 0.0, - 130.0, 0.0, - 140.0, 0.0, + 250.0, + 260.0, + 270.0, + 280.0, 0.0, 0.0, 0.0, @@ -799,6 +801,6 @@ tape( 'the function applies a unary callback to each indexed element of an n-dim t.end(); function scale( z ) { - return new Complex128( z.re*10.0, z.im*10.0 ); + return new Complex128( real(z)*10.0, imag(z)*10.0 ); } });