From 9b8176a0d8f8603f28cdeaa0b38e2876bc47e198 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Sat, 15 Nov 2025 13:47:49 +0500 Subject: [PATCH 1/3] test: add tests for complete test code coverage --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/assign/test/test.0d.js | 73 + .../ndarray/base/assign/test/test.10d.js | 2551 +++++++++++++++++ .../ndarray/base/assign/test/test.1d.js | 132 + .../ndarray/base/assign/test/test.2d.js | 1155 ++++++++ .../ndarray/base/assign/test/test.3d.js | 1295 +++++++++ .../ndarray/base/assign/test/test.4d.js | 1459 ++++++++++ .../ndarray/base/assign/test/test.5d.js | 1703 +++++++++++ .../ndarray/base/assign/test/test.6d.js | 1859 ++++++++++++ .../ndarray/base/assign/test/test.7d.js | 1999 +++++++++++++ .../ndarray/base/assign/test/test.8d.js | 2211 ++++++++++++++ .../ndarray/base/assign/test/test.9d.js | 2379 +++++++++++++++ .../@stdlib/ndarray/base/assign/test/test.js | 92 +- .../ndarray/base/assign/test/test.nd.js | 1016 +++++++ 13 files changed, 17923 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js new file mode 100644 index 000000000000..0fb5501afc6c --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js @@ -0,0 +1,73 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from n 0-dimensional input ndarray to an output ndarray', function test( t ) { + var expected; + var x; + var y; + + x = scalar2ndarray( 10.0, { + 'dtype': 'float64' + }); + y = scalar2ndarray( 0.0, { + 'dtype': 'float64' + }); + + assign( [ x, y ] ); + + expected = new Float64Array( [ 10.0 ] ); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from n 0-dimensional input ndarray to an output ndarray (accessors)', function test( t ) { + var x; + var y; + + x = ndarray( 'generic', toAccessorArray( [ 1.0 ] ), [], [ 0 ], 0, 'row-major' ); + y = ndarray( 'generic', toAccessorArray( [ 0.0 ] ), [], [ 0 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js new file mode 100644 index 000000000000..967a35ca3e41 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js @@ -0,0 +1,2551 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 9 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + 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 ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 9 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, bsize*2, 2, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, bsize*8, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, bsize*8, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 10-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js new file mode 100644 index 000000000000..ef671ec69215 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js @@ -0,0 +1,132 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 1-dimensional input ndarray to an output ndarray', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 0.0, + 1.0, + 0.0, + 2.0, + 0.0, + 3.0, + 0.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 4 ], [ 2 ], 1, 'row-major' ); + y = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 1.0, + 0.0, + 2.0, + 0.0, + 3.0, + 0.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 1-dimensional input ndarray to an output ndarray (empty array)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( 'float64', xbuf, [ 0 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 1-dimensional input ndarray to an output ndarray (accessors)', function test( t ) { + var xbuf; + var x; + var y; + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( 'generic', toAccessorArray( xbuf ), [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'generic', toAccessorArray( zeros( 4, 'generic' ) ), [ 4 ], [ 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js new file mode 100644 index 000000000000..36f053484149 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js @@ -0,0 +1,1155 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0 ], [ 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 1 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 1 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 1 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 1 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 2 ]; + st = [ 4, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 2 ]; + st = [ -4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 1 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2 ]; + st = [ bsize*4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 1 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 4, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0 ], [ 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ -1, -2 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, 4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 2 ]; + st = [ 1, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 2 ]; + st = [ 2, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 2-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2 ]; + st = [ -2, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js new file mode 100644 index 000000000000..60f42aa2df5b --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js @@ -0,0 +1,1295 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 2, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, -2, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ]; + st = [ bsize*4, 2, -2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ]; + st = [ bsize*4, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 2 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, 2, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2 ]; + st = [ 4, -2, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2 ]; + st = [ -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1 ]; + st = [ bsize*4, 2, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2 ]; + st = [ bsize*4, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 2 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 4, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' ); + y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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, -1, -2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ]; + st = [ 2, -bsize*4, bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ -1, -1, -2 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 1, 2, 4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2 ]; + st = [ 1, -2, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1 ]; + st = [ -2, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 3-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2 ]; + st = [ -2, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js new file mode 100644 index 000000000000..c375aa5864fb --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js @@ -0,0 +1,1459 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ bsize*8, bsize*4, -2, -2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ bsize*8, bsize*4, bsize*4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 3 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, 2, 1, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 4, -2, -1, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ -4, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, bsize*2, 2, 1 ]; + st = [ -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ -bsize*4, bsize*4, -2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2 ]; + st = [ -bsize*4, bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 3 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 8, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, 2, 1, bsize*2 ]; + st = [ 2, 2, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, 2, bsize*2, 1 ]; + st = [ 2, 2, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 1, bsize*2, 1, 2 ]; + st = [ 2, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 1, 2 ]; + st = [ 2, -bsize*4, bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 2, 1, 2 ]; + st = [ -1, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1 ]; + st = [ 1, 2, -4, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 8, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1 ]; + st = [ 2, -bsize*4, -bsize*4, -bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1 ]; + st = [ 1, 2, -bsize*4, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, -bsize*4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 4-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*4 ]; + st = [ 2, 4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js new file mode 100644 index 000000000000..19a8a82c449e --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js @@ -0,0 +1,1703 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0, + 9.0, + 10.0, + 11.0, + 12.0, + 13.0, + 14.0, + 15.0, + 16.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0, + 9.0, + 10.0, + 11.0, + 12.0, + 13.0, + 14.0, + 15.0, + 16.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + ybuf = zeros( 12, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + ybuf = zeros( 12, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 4 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -4, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, 2, 2, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + ybuf = zeros( 12, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 8, 4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + ybuf = zeros( 12, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ 8, -8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, -4, 4, -4, -2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, -4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 4 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0, + 9.0, + 10.0, + 11.0, + 12.0, + 13.0, + 14.0, + 15.0, + 16.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0, + 9.0, + 10.0, + 11.0, + 12.0, + 13.0, + 14.0, + 15.0, + 16.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + ybuf = zeros( 12, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + ybuf = zeros( 12, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ -1, -2, -2, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, 2, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + ybuf = zeros( 12, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 2 ]; + st = [ 1, 2, -2, -4, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + ybuf = zeros( 12, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 2 ]; + st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 2, 1, 1 ]; + st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 2 ]; + st = [ -2, 4, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 2 ]; + st = [ -2, -4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 5-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 2, 1, bsize*2 ]; + st = [ 2, 4, -4, 8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js new file mode 100644 index 000000000000..26a8db9041b7 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js @@ -0,0 +1,1859 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 2, 2, 1, 2 ]; + st = [ 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + 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 ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + 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 ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ]; + st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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 ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, bsize*2, 2 ]; + st = [ 2, 4, -4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2 ]; + st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2 ]; + st = [ 2, 4, -4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2 ]; + st = [ 2, 4, -4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 6-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js new file mode 100644 index 000000000000..656368e47920 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js @@ -0,0 +1,1999 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 5 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 5 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, 'float64' ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 6 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 6 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1 ]; + st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1 ]; + st = [ 2, 4, -4, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, 'generic' ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1 ]; + st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1 ]; + st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1 ]; + st = [ 2, 4, -4, bsize*8, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 7-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( 'generic' ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, -4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, 'generic' ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js new file mode 100644 index 000000000000..c0a585203289 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js @@ -0,0 +1,2211 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 7 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + 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 ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 7 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, bsize*2, 2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 8-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js new file mode 100644 index 000000000000..4dddaf324dc6 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js @@ -0,0 +1,2379 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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 ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 8 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + 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 ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1, 1 ]; + st = [ 8, -8, -4, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -4, -4, 4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, bsize*8, -4, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, -4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, 2, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ bsize*4, -bsize*4, -bsize*4, -bsize*4, -bsize*4, bsize*4, 2, 2, 2 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + 2, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ + bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + -bsize*4, + bsize*4, + bsize*4, + bsize*4, + 2 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 8 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 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' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'float64'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, bsize*2, 2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays)', function test( t ) { + var expected; + var bsize; + var xbuf; + var ybuf; + 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, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, 4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array( numel( sh )*2 ); + dfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array( x.length*2 ); + dfill( x.length, 1.0, expected, st[ 0 ] ); + + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 1, 1 ]; + st = [ + 2, + bsize*4, + -bsize*4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 1, 1 ]; + st = [ + 2, + 4, + -bsize*8, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, bsize*2, 1, 1, 2, 1, 1, 1 ]; + st = [ + 2, + 4, + -4, + bsize*8, + bsize*8, + bsize*8, + bsize*16, + bsize*16, + bsize*16 + ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, bsize*2, 1, 2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, bsize*2, 2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, bsize*8, bsize*16, bsize*16, bsize*16 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, bsize*2, 1, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, bsize*8, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, bsize*2, 1, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, bsize*8, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, bsize*2, 1 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4, bsize*8 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a 9-dimensional input ndarray to an output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) { + var bsize; + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + + bsize = blockSize( dt ); + sh = [ 2, 1, 1, 1, 1, 1, 1, 1, bsize*2 ]; + st = [ 2, 4, -4, 4, 4, -4, 4, 4, 4 ]; + o = strides2offset( sh, st ); + + xbuf = zeros( numel( sh )*2, dt ); + gfill( numel( sh ), 1.0, xbuf, st[ 0 ] ); + ybuf = zeros( numel( sh )*2, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js index 35bcec91307b..313228ee6421 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js @@ -21,6 +21,11 @@ // MODULES // var tape = require( 'tape' ); +var BooleanArray = require( '@stdlib/array/bool' ); +var zeros = require( '@stdlib/array/zeros' ); +var ndarray = require( '@stdlib/ndarray/ctor' ); +var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); var assign = require( './../lib' ); @@ -32,4 +37,89 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -// FIXME: add tests +tape( 'the function throws an error if provided a ndarrays which doesnot have the same shape', function test( t ) { + var values; + var x; + var y; + var i; + + x = ndarray( 'generic', [ 1.0, 2.0, 3.0, 4.0 ], [ 4 ], [ 1 ], 0, 'row-major' ); + + values = [ + [ 2 ], + [ 3 ], + [ 5 ], + [ 6 ] + ]; + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + y = ndarray( 'float64', zeros( 8, 'float64' ), value, [ 1 ], 0, 'row-major' ); + assign( [ x, y ] ); + }; + } +}); + +tape( 'the function assigns elements from an input ndarray to an output ndarray (boolean)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new BooleanArray([ + true, + false, + true, + false + ]); + x = ndarray( 'bool', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'bool', zeros( 4, 'bool' ), [ 4 ], [ 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new BooleanArray( [ true, false, true, false ] ); + + t.deepEqual( expected, y.data, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from an input ndarray to an output ndarray (complex)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Complex128Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ]); + x = ndarray( 'complex128', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 4 ], [ 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Complex128Array([ + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0, + 10.0 + ]); + t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js new file mode 100644 index 000000000000..d57d93aa72f8 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js @@ -0,0 +1,1016 @@ +/** +* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var zeros = require( '@stdlib/array/zeros' ); +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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var assign = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof assign, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 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, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ -8, -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, 16, 8, 4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'row-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ]; + st = [ 16, 16, 16, 16, 16, 16, -16, 8, -4, 4, 1 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 0.0, + 0.0, + 3.0, + 4.0, + 0.0, + 0.0, + 5.0, + 6.0, + 0.0, + 0.0, + 7.0, + 8.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { + var expected; + var xbuf; + 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, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { + var expected; + var xbuf; + var x; + var y; + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0 + ]); + x = ndarray( 'float64', xbuf, [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 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, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { + var expected; + var xbuf; + 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, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { + var expected; + var xbuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { + var expected; + var xbuf; + var ybuf; + 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, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 2, -2, -4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + ybuf = zeros( 16, dt ); + x = ndarray( dt, xbuf, sh, st, o, ord ); + y = ndarray( dt, ybuf, sh, st, o, ord ); + + assign( [ x, y ] ); + + expected = new Float64Array([ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]); + t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = shape2strides( sh, ord ); + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { + var xbuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ -1, -1, -1, -1, -1, -1, -2, -2, -4, -4, -4 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 8.0 + ]; + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 2, 2, 4, 4, 8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { + var xbuf; + var ybuf; + var ord; + var sh; + var st; + var dt; + var o; + var x; + var y; + + dt = 'generic'; + ord = 'column-major'; + sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2 ]; + st = [ 1, 1, 1, 1, 1, 1, 2, -2, -4, -8, -8 ]; + o = strides2offset( sh, st ); + + xbuf = [ + 1.0, + 2.0, + 3.0, + 4.0, + 0.0, + 0.0, + 0.0, + 0.0, + 5.0, + 6.0, + 7.0, + 8.0, + 0.0, + 0.0, + 0.0, + 0.0 + ]; + ybuf = zeros( 16, dt ); + x = ndarray( dt, toAccessorArray( xbuf ), sh, st, o, ord ); + y = ndarray( dt, toAccessorArray( ybuf ), sh, st, o, ord ); + + assign( [ x, y ] ); + + t.strictEqual( isSameAccessorArray( x.data, y.data ), true, 'returns expected value' ); + + t.end(); +}); From ae180344847dc75a1005af91860b65c68dc955cb Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Sun, 29 Mar 2026 12:24:45 +0000 Subject: [PATCH 2/3] chore: update copyright years --- lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js | 2 +- lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js | 2 +- 12 files changed, 12 insertions(+), 12 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js index 0fb5501afc6c..aa56f4c05da4 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js index 967a35ca3e41..b30ec955932e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.10d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js index ef671ec69215..45ae51e421d1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.1d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js index 36f053484149..6afd332d46e2 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.2d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js index 60f42aa2df5b..0ca11ba00d50 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.3d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js index c375aa5864fb..9dac67ab5a32 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.4d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js index 19a8a82c449e..97de85a8c952 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.5d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js index 26a8db9041b7..0375478dcb53 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.6d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js index 656368e47920..9e2b56a46eeb 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.7d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js index c0a585203289..bef742a424cf 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.8d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js index 4dddaf324dc6..967374277827 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.9d.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js index d57d93aa72f8..3d3f02de8356 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 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. From 0989e07fd11338ae7cb3d5fc33a5f98350ee44f5 Mon Sep 17 00:00:00 2001 From: headlessNode Date: Wed, 22 Jul 2026 00:52:28 +0500 Subject: [PATCH 3/3] fix: apply suggestions from code review --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../ndarray/base/assign/test/test.0d.js | 4 +- .../@stdlib/ndarray/base/assign/test/test.js | 6 +-- .../ndarray/base/assign/test/test.nd.js | 44 +++++++++---------- 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js index aa56f4c05da4..59a80844587c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.0d.js @@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function assigns elements from n 0-dimensional input ndarray to an output ndarray', function test( t ) { +tape( 'the function assigns elements from a 0-dimensional input ndarray to an output ndarray', function test( t ) { var expected; var x; var y; @@ -58,7 +58,7 @@ tape( 'the function assigns elements from n 0-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from n 0-dimensional input ndarray to an output ndarray (accessors)', function test( t ) { +tape( 'the function assigns elements from a 0-dimensional input ndarray to an output ndarray (accessors)', function test( t ) { var x; var y; diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js index 313228ee6421..607e90359de7 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.js @@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function throws an error if provided a ndarrays which doesnot have the same shape', function test( t ) { +tape( 'the function throws an error if provided ndarrays which do not have the same shape', function test( t ) { var values; var x; var y; @@ -77,13 +77,13 @@ tape( 'the function assigns elements from an input ndarray to an output ndarray false ]); x = ndarray( 'bool', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); - y = ndarray( 'bool', zeros( 4, 'bool' ), [ 4 ], [ 1 ], 0, 'row-major' ); + y = ndarray( 'bool', new BooleanArray( 4 ), [ 4 ], [ 1 ], 0, 'row-major' ); assign( [ x, y ] ); expected = new BooleanArray( [ true, false, true, false ] ); - t.deepEqual( expected, y.data, 'returns expected value' ); + t.deepEqual( y.data, expected, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js index 3d3f02de8356..d50e29963c44 100644 --- a/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js +++ b/lib/node_modules/@stdlib/ndarray/base/assign/test/test.nd.js @@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions)', function test( t ) { var expected; var xbuf; var ord; @@ -80,7 +80,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, singleton dimensions, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -112,7 +112,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, empty)', function test( t ) { var expected; var xbuf; var x; @@ -140,7 +140,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, contiguous)', function test( t ) { var expected; var xbuf; var ord; @@ -187,7 +187,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides)', function test( t ) { var expected; var xbuf; var ord; @@ -234,7 +234,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) { var expected; var xbuf; var ybuf; @@ -299,7 +299,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) { var expected; var xbuf; var ybuf; @@ -364,7 +364,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, contiguous, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -400,7 +400,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -436,7 +436,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) { var xbuf; var ybuf; var ord; @@ -482,7 +482,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { var xbuf; var ybuf; var ord; @@ -528,7 +528,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions)', function test( t ) { var expected; var xbuf; var ord; @@ -567,7 +567,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, singleton dimensions, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -599,7 +599,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, empty)', function test( t ) { var expected; var xbuf; var x; @@ -627,7 +627,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, contiguous)', function test( t ) { var expected; var xbuf; var ord; @@ -674,7 +674,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides)', function test( t ) { var expected; var xbuf; var ord; @@ -721,7 +721,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) { var expected; var xbuf; var ybuf; @@ -786,7 +786,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) { var expected; var xbuf; var ybuf; @@ -851,7 +851,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, contiguous, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -887,7 +887,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) { var xbuf; var ord; var sh; @@ -923,7 +923,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) { var xbuf; var ybuf; var ord; @@ -969,7 +969,7 @@ tape( 'the function assigns elements from a n-dimensional input ndarray to an ou t.end(); }); -tape( 'the function assigns elements from a n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { +tape( 'the function assigns elements from an n-dimensional input ndarray to an output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) { var xbuf; var ybuf; var ord;