diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js
new file mode 100644
index 000000000000..a0d01e23dc0f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.0d.js
@@ -0,0 +1,89 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 0-dimensional ndarray', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+
+	y = scalar2ndarray( 0.0, {
+		'dtype': 'float64'
+	});
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( [ 50.0 ] );
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 0-dimensional ndarray (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = scalar2ndarray( new Complex128( 5.0, 5.0 ), {
+		'dtype': 'complex128'
+	});
+
+	y = scalar2ndarray( new Complex128( 0.0, 0.0 ), {
+		'dtype': 'complex128'
+	});
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( [ 50.0, 50.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js
new file mode 100644
index 000000000000..df82e8fc5d1f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.10d.js
@@ -0,0 +1,2606 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*16,
+		-8,
+		4,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 9 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*16,
+		-8,
+		4,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 9 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1, 1 ];
+	st = [ -1, -1, -1, -1, -1, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset(sh, st);
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		-bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		-bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 10-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js
new file mode 100644
index 000000000000..0c2eeba53b30
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.1d.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 4 ], [ 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray (empty array)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ), [ 0 ], [ 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 1-dimensional ndarray (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'complex128', new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 4 ], [ 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js
new file mode 100644
index 000000000000..e19ae6da0070
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.2d.js
@@ -0,0 +1,1175 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 0 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ 2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ -2, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ 2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 2-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ -2, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js
new file mode 100644
index 000000000000..35100fbc94e5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.3d.js
@@ -0,0 +1,1306 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var oneTo = require( '@stdlib/array/one-to' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		40.0,
+		50.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		40.0,
+		50.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (row-major, non-contiguous, large arrays, accessors', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		40.0,
+		50.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 6, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		40.0,
+		50.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1 ];
+	st = [ 2, -4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1 ];
+	st = [ -2, bsize*4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1 ];
+	st = [ 2, -4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a nullary callback to each indexed element of a 3-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js
new file mode 100644
index 000000000000..4f3f575917df
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.4d.js
@@ -0,0 +1,1470 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, 2, 1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, -2, -1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ -4, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 3 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2, 1 ];
+	st = [ -bsize*8, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 3 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ bsize*8, bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 3 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, bsize*4, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 3 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, 2, 1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, -2, -1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ -4, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2, 1 ];
+	st = [ -bsize*8, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ bsize*8, bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, bsize*4, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 3 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, -2, -4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 8, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ 2, 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ 2, 2, -4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 1, 2 ];
+	st = [ 2, 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ 2, -bsize*4, -bsize*4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1 ];
+	st = [ 1, 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1 ];
+	st = [ 2, 4, -4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 4-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*4 ];
+	st = [ 2, 4, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js
new file mode 100644
index 000000000000..0369c5715fff
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.5d.js
@@ -0,0 +1,1697 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2, 2 ];
+	st = [ -8, -4, -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, 2, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, -2, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ 8, -8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 4 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, -4, 4, -4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 4 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 4 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 4 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 4 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( x ) {
+		return x * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, 2, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ 8, -8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, -4, 4, -4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 4 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2, 2 ];
+	st = [ -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, -2, -4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ -2, 4, -bsize*8, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ -2, 4, -4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ -2, 4, -4, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ -2, 4, -4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1 ];
+	st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ -2, 4, -4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ -2, -4, -4, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 5-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, 4, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js
new file mode 100644
index 000000000000..137c95de38c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.6d.js
@@ -0,0 +1,1861 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, -16, 8, -4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 8, -8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ bsize*8, -4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 5 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, -4, -4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 8, -8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ bsize*8, -4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 5 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', ones( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, -1, 1, -2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 12, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 1 ];
+	st = [ 2, 4, 4, -4, 8, -bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ 2, 4, 4, -8, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z*10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 1 ];
+	st = [ 2, 4, 4, -4, 8, -bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 6-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ 2, 4, 4, -8, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js
new file mode 100644
index 000000000000..8b0e3c096bb7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.7d.js
@@ -0,0 +1,2050 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z) * 10.0, imag(z) * 10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -16, 16, -16, 8, -4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 16, -16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*16, -8, 8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 6 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -8, -8, -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		290.0,
+		300.0,
+		310.0,
+		320.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -16, 16, -16, -8, 4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 16, -16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ bsize*16, -8, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 6 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		0.0,
+		30.0,
+		0.0,
+		50.0,
+		0.0,
+		70.0,
+		0.0,
+		90.0,
+		0.0,
+		110.0,
+		0.0,
+		130.0,
+		0.0,
+		150.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, -1, 2, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		0.0,
+		30.0,
+		0.0,
+		50.0,
+		0.0,
+		70.0,
+		0.0,
+		90.0,
+		0.0,
+		110.0,
+		0.0,
+		130.0,
+		0.0,
+		150.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, bsize*8, -bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 2, 1, 2, 1 ];
+	st = [ 2, -4, bsize*8, bsize*8, -bsize*16, bsize*16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 1, 2 ];
+	st = [ 2, -4, -4, 4, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, -4, -4, 8, 8, 16, 16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		210.0,
+		220.0,
+		230.0,
+		240.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		290.0,
+		300.0,
+		310.0,
+		320.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		0.0,
+		0.0,
+		210.0,
+		220.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		0.0,
+		0.0,
+		290.0,
+		300.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, 1, -1, -2, 4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		0.0,
+		0.0,
+		210.0,
+		220.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		0.0,
+		0.0,
+		290.0,
+		300.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ];
+	st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 7-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, -4, -4, 8, 8, 16, 16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js
new file mode 100644
index 000000000000..e615e4a405ef
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.8d.js
@@ -0,0 +1,2168 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ];
+	st = [ 32, -16, 8, -8, -8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ];
+	st = [
+		-bsize*16,
+		-bsize*16,
+		bsize*8,
+		-bsize*8,
+		-bsize*8,
+		bsize*4,
+		-bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 7 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ];
+	st = [ 32, 16, 8, -8, -8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ];
+	st = [
+		-bsize*16,
+		-bsize*16,
+		bsize*8,
+		-bsize*8,
+		-bsize*8,
+		bsize*4,
+		-bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 7 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset(sh, st);
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an 8-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js
new file mode 100644
index 000000000000..45947ff99d58
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.9d.js
@@ -0,0 +1,2390 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var ones = require( '@stdlib/array/ones' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'row-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		-bsize*64,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		-4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 8 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		-bsize*64,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		-4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 8 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = ndarray( 'float64', oneTo( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 0, 'column-major' );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset(sh, st);
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, ones( numel( sh ) * 2, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array( x.length*2 );
+	dfill( x.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, contiguous, accessors, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of a 9-dimensional ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( ones( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ) * 2, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array( x.length*2 );
+	gfill( x.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js
index 8cfddde2e3cd..2dd705e946d8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.js
@@ -21,6 +21,12 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
 var unary = require( './../lib' );
 
 
@@ -32,4 +38,100 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-// FIXME: add tests
+tape( 'the function throws an error if provided input and output ndarrays which do not have the same number of dimensions', function test( t ) {
+	var shapes;
+	var i;
+
+	shapes = [
+		[ [ 4, 2, 1 ], [ 4, 2 ] ],
+		[ [ 2, 2 ], [ 2, 2, 2 ] ],
+		[ [ 1, 1, 1, 1 ], [ 1, 1, 1 ] ],
+		[ [ 2, 2, 1, 2 ], [ 2, 1, 2 ] ],
+		[ [ 1, 1, 4, 2, 2, 2 ], [ 10, 2 ] ],
+		[ [ 1, 1, 1, 1 ], [ 1, 1, 1 ] ]
+	];
+
+	for ( i = 0; i < shapes.length; i++ ) {
+		t.throws( badValue( shapes[i][0], shapes[i][1] ), Error, 'throws an error when input shape is ' + shapes[i][0] + ' and output shape is ' + shapes[i][1] );
+	}
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+
+	function badValue( sh1, sh2 ) {
+		return function badValue() {
+			var dtype;
+			var ord;
+			var st1;
+			var st2;
+			var o1;
+			var o2;
+			var x;
+			var y;
+
+			ord = 'row-major';
+			dtype = 'float64';
+
+			st1 = shape2strides( sh1, ord );
+			st2 = shape2strides( sh2, ord );
+			o1 = strides2offset( sh1, st1 );
+			o2 = strides2offset( sh2, st2 );
+
+			x = ndarray( dtype, ones( numel( sh1 ), dtype ), sh1, st1, o1, ord );
+			y = ndarray( dtype, zeros( numel( sh2 ), dtype ), sh2, st2, o2, ord );
+
+			unary( [ x, y ], scale );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided input and output ndarrays which do not have the same shape', function test( t ) {
+	var shapes;
+	var i;
+
+	shapes = [
+		[ [ 4, 2, 1 ], [ 4, 2, 2 ] ],
+		[ [ 3, 3 ], [ 2, 2 ] ],
+		[ [ 5, 5, 5 ], [ 5, 5, 4 ] ],
+		[ [ 1, 1, 1 ], [ 2, 2, 2 ] ],
+		[ [ 1, 4, 1, 2, 2 ], [ 3, 8 ] ],
+		[ [ 10, 2, 1 ], [ 1, 2, 10 ] ]
+	];
+
+	for ( i = 0; i < shapes.length; i++ ) {
+		t.throws( badValue( shapes[i][0], shapes[i][1] ), Error, 'throws an error when input shape is ' + shapes[i][0] + ' and output shape is ' + shapes[i][1] );
+	}
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+
+	function badValue( sh1, sh2 ) {
+		return function badValue() {
+			var dtype;
+			var ord;
+			var st1;
+			var st2;
+			var o1;
+			var o2;
+			var x;
+			var y;
+
+			ord = 'row-major';
+			dtype = 'float64';
+
+			st1 = shape2strides( sh1, ord );
+			st2 = shape2strides( sh2, ord );
+			o1 = strides2offset( sh1, st1 );
+			o2 = strides2offset( sh2, st2 );
+
+			x = ndarray( dtype, ones( numel( sh1 ), dtype ), sh1, st1, o1, ord );
+			y = ndarray( dtype, zeros( numel( sh2 ), dtype ), sh2, st2, o2, ord );
+
+			unary( [ x, y ], scale );
+		};
+	}
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js
new file mode 100644
index 000000000000..a550a886d9e7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/unary/test/test.nd.js
@@ -0,0 +1,806 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var oneTo = require( '@stdlib/array/one-to' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var unary = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof unary, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset(sh, st);
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape('the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, oneTo( 16, dt ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Float64Array([
+		10.0,
+		20.0,
+		0.0,
+		0.0,
+		50.0,
+		60.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		0.0,
+		0.0,
+		130.0,
+		140.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return z * 10.0;
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 2, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		50.0,
+		60.0,
+		70.0,
+		80.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		130.0,
+		140.0,
+		150.0,
+		160.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});
+
+tape( 'the function applies a unary callback to each indexed element of an n-dimensional ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, new Complex128Array( oneTo( numel( sh ) * 4, 'float64' ) ), sh, st, o, ord );
+	y = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	unary( [ x, y ], scale );
+
+	expected = new Complex128Array([
+		10.0,
+		20.0,
+		30.0,
+		40.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		90.0,
+		100.0,
+		110.0,
+		120.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		170.0,
+		180.0,
+		190.0,
+		200.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		250.0,
+		260.0,
+		270.0,
+		280.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.end();
+
+	function scale( z ) {
+		return new Complex128( real(z)*10.0, imag(z)*10.0 );
+	}
+});