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();
+});