diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/README.md b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/README.md new file mode 100644 index 000000000000..ed1589cb29e8 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/README.md @@ -0,0 +1,135 @@ + + +# reverseDimensions + +> Return a view of an input ndarray in which the order of elements along specified dimensions is reversed. + + + +
+ +
+ + + + + +
+ +## Usage + +```javascript +var reverseDimensions = require( '@stdlib/ndarray/base/reverse-dimensions' ); +``` + +#### reverseDimensions( x, dims, writable ) + +Returns a view of an input ndarray in which the order of elements along specified dimensions is reversed. + +```javascript +var array = require( '@stdlib/ndarray/array' ); + +var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] ); +// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] + +var y = reverseDimensions( x, [ 0, 1 ], false ); +// returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ] +``` + +The function accepts the following arguments: + +- **x**: input ndarray. +- **dims**: dimension indices along which to reverse elements. If provided an integer less than zero, the dimension index is resolved relative to the last dimension, with the last dimension corresponding to the value `-1`. +- **writable**: boolean indicating whether a returned ndarray should be writable. + +
+ + + + + +
+ +## Notes + +- The `writable` parameter **only** applies to ndarray constructors supporting **read-only** instances. + +
+ + + + + +
+ +## Examples + + + +```javascript +var array = require( '@stdlib/ndarray/array' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var zeroTo = require( '@stdlib/array/base/zero-to' ); +var reverseDimensions = require( '@stdlib/ndarray/base/reverse-dimensions' ); + +// Create a linear ndarray buffer: +var buf = zeroTo( 16 ); + +// Create a three-dimensional ndarray: +var x = array( buf, { + 'shape': [ 2, 4, 2 ] +}); +// returns [ [ [ 0.0, 1.0 ], [ 2.0, 3.0 ], [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ], [ 12.0, 13.0 ], [ 14.0, 15.0 ] ] ] + +// Reverse elements across all dimensions: +var y = reverseDimensions( x, [ 0, 1, 2 ], false ); +// returns [ [ [ 15.0, 14.0 ], [ 13.0, 12.0 ], [ 11.0, 10.0 ], [ 9.0, 8.0 ] ], [ [ 7.0, 6.0 ], [ 5.0, 4.0 ], [ 3.0, 2.0 ], [ 1.0, 0.0 ] ] ] + +console.log( ndarray2array( y ) ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +
+ + + + + +
+ +
+ + diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/benchmark/benchmark.js new file mode 100644 index 000000000000..82bb05ba3395 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/benchmark/benchmark.js @@ -0,0 +1,332 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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 bench = require( '@stdlib/bench' ); +var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' ); +var baseEmpty = require( '@stdlib/ndarray/base/empty' ); +var empty = require( '@stdlib/ndarray/empty' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var reverseDimensions = require( './../lib' ); + + +// MAIN // + +bench( format( '%s::1d,base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + values = [ + baseEmpty( 'float64', [ 2 ], 'row-major' ), + baseEmpty( 'float32', [ 2 ], 'row-major' ), + baseEmpty( 'int32', [ 2 ], 'row-major' ), + baseEmpty( 'complex128', [ 2 ], 'row-major' ), + baseEmpty( 'generic', [ 2 ], 'row-major' ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::1d,non-base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + /* eslint-disable object-curly-newline */ + + values = [ + empty( [ 2 ], { 'dtype': 'float64' }), + empty( [ 2 ], { 'dtype': 'float32' }), + empty( [ 2 ], { 'dtype': 'int32' }), + empty( [ 2 ], { 'dtype': 'complex128' }), + empty( [ 2 ], { 'dtype': 'generic' }) + ]; + + /* eslint-enable object-curly-newline */ + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::2d,base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + values = [ + baseEmpty( 'float64', [ 2, 2 ], 'row-major' ), + baseEmpty( 'float32', [ 2, 2 ], 'row-major' ), + baseEmpty( 'int32', [ 2, 2 ], 'row-major' ), + baseEmpty( 'complex128', [ 2, 2 ], 'row-major' ), + baseEmpty( 'generic', [ 2, 2 ], 'row-major' ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::2d,non-base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + /* eslint-disable object-curly-newline */ + + values = [ + empty( [ 2, 2 ], { 'dtype': 'float64' }), + empty( [ 2, 2 ], { 'dtype': 'float32' }), + empty( [ 2, 2 ], { 'dtype': 'int32' }), + empty( [ 2, 2 ], { 'dtype': 'complex128' }), + empty( [ 2, 2 ], { 'dtype': 'generic' }) + ]; + + /* eslint-enable object-curly-newline */ + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::3d,base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + values = [ + baseEmpty( 'float64', [ 2, 2, 2 ], 'row-major' ), + baseEmpty( 'float32', [ 2, 2, 2 ], 'row-major' ), + baseEmpty( 'int32', [ 2, 2, 2 ], 'row-major' ), + baseEmpty( 'complex128', [ 2, 2, 2 ], 'row-major' ), + baseEmpty( 'generic', [ 2, 2, 2 ], 'row-major' ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::3d,non-base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + /* eslint-disable object-curly-newline */ + + values = [ + empty( [ 2, 2, 2 ], { 'dtype': 'float64' }), + empty( [ 2, 2, 2 ], { 'dtype': 'float32' }), + empty( [ 2, 2, 2 ], { 'dtype': 'int32' }), + empty( [ 2, 2, 2 ], { 'dtype': 'complex128' }), + empty( [ 2, 2, 2 ], { 'dtype': 'generic' }) + ]; + + /* eslint-enable object-curly-newline */ + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2 ], false ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::4d,base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + values = [ + baseEmpty( 'float64', [ 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'float32', [ 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'int32', [ 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'complex128', [ 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'generic', [ 2, 2, 2, 2 ], 'row-major' ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2, 3 ], false ); // eslint-disable-line max-len + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::4d,non-base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + /* eslint-disable object-curly-newline */ + + values = [ + empty( [ 2, 2, 2, 2 ], { 'dtype': 'float64' }), + empty( [ 2, 2, 2, 2 ], { 'dtype': 'float32' }), + empty( [ 2, 2, 2, 2 ], { 'dtype': 'int32' }), + empty( [ 2, 2, 2, 2 ], { 'dtype': 'complex128' }), + empty( [ 2, 2, 2, 2 ], { 'dtype': 'generic' }) + ]; + + /* eslint-enable object-curly-newline */ + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2, 3 ], false ); // eslint-disable-line max-len + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::5d,base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + values = [ + baseEmpty( 'float64', [ 2, 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'float32', [ 2, 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'int32', [ 2, 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'complex128', [ 2, 2, 2, 2, 2 ], 'row-major' ), + baseEmpty( 'generic', [ 2, 2, 2, 2, 2 ], 'row-major' ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2, 3, 4 ], false ); // eslint-disable-line max-len + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( format( '%s::5d,non-base', pkg ), function benchmark( b ) { + var values; + var v; + var i; + + /* eslint-disable object-curly-newline */ + + values = [ + empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'float64' }), + empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'float32' }), + empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'int32' }), + empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'complex128' }), + empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'generic' }) + ]; + + /* eslint-enable object-curly-newline */ + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = reverseDimensions( values[ i%values.length ], [ 0, 1, 2, 3, 4 ], false ); // eslint-disable-line max-len + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( !isndarrayLike( v ) ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/repl.txt new file mode 100644 index 000000000000..ca9c3fc9a880 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/repl.txt @@ -0,0 +1,35 @@ + +{{alias}}( x, dims, writable ) + Returns a view of an input ndarray in which the order of elements along + specified dimensions is reversed. + + Parameters + ---------- + x: ndarray + Input array. + + dims: ArrayLikeObject + Dimension indices along which to reverse elements. If less than zero, + the index is resolved relative to the last dimension, with the last + dimension corresponding to the value `-1`. + + writable: boolean + Boolean indicating whether a returned ndarray should be writable. This + parameter only applies to ndarray constructors which support read-only + instances. + + Returns + ------- + out: ndarray + Output array view. + + Examples + -------- + > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1, 2 ], [ 3, 4 ] ] ) + [ [ 1, 2 ], [ 3, 4 ] ] + > var y = {{alias}}( x, [ 0, 1 ], false ) + [ [ 4, 3 ], [ 2, 1 ] ] + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/index.d.ts new file mode 100644 index 000000000000..88b211566789 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/index.d.ts @@ -0,0 +1,104 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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. +*/ + +// TypeScript Version: 4.1 + +/// + +import { typedndarray, genericndarray, complexndarray } from '@stdlib/types/ndarray'; + +/** +* Returns a view of an input ndarray in which the order of elements along specified dimensions is reversed. +* +* @param x - input array +* @param dims - indices of dimension to reverse +* @param writable - boolean indicating whether a returned array should be writable +* @returns output array +* +* @example +* var typedarray = require( '@stdlib/array/typed' ); +* var ndarray = require( '@stdlib/ndarray/ctor' ); +* +* var buffer = [ 1, 2, 3, 4, 5, 6 ]; +* var shape = [ 3, 2 ]; +* var strides = [ 2, 1 ]; +* var offset = 0; +* +* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' ); +* // returns [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ] +* +* var y = reverseDimensions( x, [ 0, 1 ], false ); +* // returns [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ] +*/ +declare function reverseDimensions( x: typedndarray, dims: Array, writable: boolean ): typedndarray; + +/** +* Returns a view of an input ndarray in which the order of elements along specified dimensions is reversed. +* +* @param x - input array +* @param dims - indices of dimension to reverse +* @param writable - boolean indicating whether a returned array should be writable +* @returns output array +* +* @example +* var typedarray = require( '@stdlib/array/typed' ); +* var ndarray = require( '@stdlib/ndarray/ctor' ); +* +* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ], 'complex64' ); +* var shape = [ 3, 2 ]; +* var strides = [ 2, 1 ]; +* var offset = 0; +* +* var x = ndarray( 'complex64', buffer, shape, strides, offset, 'row-major' ); +* // returns +* +* var y = reverseDimensions( x, [ 0 ], false ); +* // returns +*/ +declare function reverseDimensions( x: complexndarray, dims: Array, writable: boolean ): complexndarray; + +/** +* Returns a view of an input ndarray in which the order of elements along specified dimensions is reversed. +* +* @param x - input array +* @param dims - indices of dimension to reverse +* @param writable - boolean indicating whether a returned array should be writable +* @returns output array +* +* @example +* var typedarray = require( '@stdlib/array/typed' ); +* var ndarray = require( '@stdlib/ndarray/ctor' ); +* var ndarray2array = require( '@stdlib/ndarray/to-array' ); +* +* var buffer = [ 1, 2, 3, 4, 5, 6 ]; +* var shape = [ 3, 2 ]; +* var strides = [ 2, 1 ]; +* var offset = 0; +* +* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' ); +* // returns [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ] +* +* var y = reverseDimensions( x, [ 0, 1 ], false ); +* // returns [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ] +*/ +declare function reverseDimensions( x: genericndarray, dims: Array, writable: boolean ): genericndarray; + + +// EXPORTS // + +export = reverseDimensions; diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/test.ts new file mode 100644 index 000000000000..cdf56eb2dfe6 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/docs/types/test.ts @@ -0,0 +1,119 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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. +*/ + +import empty = require( '@stdlib/ndarray/base/empty' ); +import reverseDimensions = require( './index' ); + + +// TESTS // + +// The function returns an ndarray... +{ + const order = 'row-major'; + const sh = [ 2, 2 ]; + + reverseDimensions( empty( 'float64', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'float32', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'complex128', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'complex64', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'int32', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'int16', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'int8', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint32', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint16', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint8', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint8c', sh, order ), [ 0 ], false ); // $ExpectType typedndarray + + reverseDimensions( empty( 'float64', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'float32', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'complex128', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'complex64', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'int32', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'int16', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'int8', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint32', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint16', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint8', sh, order ), [ 0 ], true ); // $ExpectType typedndarray + reverseDimensions( empty( 'uint8c', sh, order ), [ 0 ], true ); // $ExpectType typedndarray +} + +// The compiler throws an error if the function is provided a first argument which is not an ndarray... +{ + reverseDimensions( '10', [ 0 ], false ); // $ExpectError + reverseDimensions( 10, [ 0 ], false ); // $ExpectError + reverseDimensions( false, [ 0 ], false ); // $ExpectError + reverseDimensions( true, [ 0 ], false ); // $ExpectError + reverseDimensions( null, [ 0 ], false ); // $ExpectError + reverseDimensions( [], [ 0 ], false ); // $ExpectError + reverseDimensions( {}, [ 0 ], false ); // $ExpectError + reverseDimensions( ( x: number ): number => x, [ 0 ], false ); // $ExpectError + + reverseDimensions( '10', [ 0 ], true ); // $ExpectError + reverseDimensions( 10, [ 0 ], true ); // $ExpectError + reverseDimensions( false, [ 0 ], true ); // $ExpectError + reverseDimensions( true, [ 0 ], true ); // $ExpectError + reverseDimensions( null, [ 0 ], true ); // $ExpectError + reverseDimensions( [], [ 0 ], true ); // $ExpectError + reverseDimensions( {}, [ 0 ], true ); // $ExpectError + reverseDimensions( ( x: number ): number => x, [ 0 ], true ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not an array of integers... +{ + const x = empty( 'float64', [ 2, 2 ], 'row-major' ); + + reverseDimensions( x, '5', false ); // $ExpectError + reverseDimensions( x, true, false ); // $ExpectError + reverseDimensions( x, false, false ); // $ExpectError + reverseDimensions( x, null, false ); // $ExpectError + reverseDimensions( x, undefined, false ); // $ExpectError + reverseDimensions( x, [ '5' ], false ); // $ExpectError + reverseDimensions( x, {}, false ); // $ExpectError + reverseDimensions( x, ( x: number ): number => x, false ); // $ExpectError + + reverseDimensions( x, '5', true ); // $ExpectError + reverseDimensions( x, true, true ); // $ExpectError + reverseDimensions( x, false, true ); // $ExpectError + reverseDimensions( x, null, true ); // $ExpectError + reverseDimensions( x, undefined, true ); // $ExpectError + reverseDimensions( x, [ '5' ], true ); // $ExpectError + reverseDimensions( x, {}, true ); // $ExpectError + reverseDimensions( x, ( x: number ): number => x, true ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a boolean... +{ + const x = empty( 'float64', [ 2, 2 ], 'row-major' ); + + reverseDimensions( x, [ 0 ], '5' ); // $ExpectError + reverseDimensions( x, [ 0 ], 5 ); // $ExpectError + reverseDimensions( x, [ 0 ], null ); // $ExpectError + reverseDimensions( x, [ 0 ], undefined ); // $ExpectError + reverseDimensions( x, [ 0 ], [ '5' ] ); // $ExpectError + reverseDimensions( x, [ 0 ], {} ); // $ExpectError + reverseDimensions( x, [ 0 ], ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = empty( 'float64', [ 2, 2 ], 'row-major' ); + + reverseDimensions( x ); // $ExpectError + reverseDimensions( x, 0 ); // $ExpectError + reverseDimensions( x, [ 0 ], false, {} ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/examples/index.js new file mode 100644 index 000000000000..c8baef9dd505 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/examples/index.js @@ -0,0 +1,39 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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'; + +var array = require( '@stdlib/ndarray/array' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var zeroTo = require( '@stdlib/array/base/zero-to' ); +var reverseDimensions = require( './../lib' ); + +// Create a linear ndarray buffer: +var buf = zeroTo( 16 ); + +// Create a three-dimensional ndarray: +var x = array( buf, { + 'shape': [ 2, 4, 2 ] +}); +// returns [ [ [ 0.0, 1.0 ], [ 2.0, 3.0 ], [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ], [ 12.0, 13.0 ], [ 14.0, 15.0 ] ] ] + +// Reverse elements across all dimensions: +var y = reverseDimensions( x, [ 0, 1, 2 ], false ); +// returns [ [ [ 15.0, 14.0 ], [ 13.0, 12.0 ], [ 11.0, 10.0 ], [ 9.0, 8.0 ] ], [ [ 7.0, 6.0 ], [ 5.0, 4.0 ], [ 3.0, 2.0 ], [ 1.0, 0.0 ] ] ] + +console.log( ndarray2array( y ) ); diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/index.js new file mode 100644 index 000000000000..11b69ac4155f --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/index.js @@ -0,0 +1,44 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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'; + +/** +* Return a view of an input ndarray in which the order of elements along specified dimensions is reversed. +* +* @module @stdlib/ndarray/base/reverse-dimensions +* +* @example +* var array = require( '@stdlib/ndarray/array' ); +* var reverseDimensions = require( '@stdlib/ndarray/base/reverse-dimensions' ); +* +* var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] ); +* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] +* +* var y = reverseDimensions( x, [ 0, 1 ], false ); +* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ] +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/main.js new file mode 100644 index 000000000000..fc3cad486b24 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/lib/main.js @@ -0,0 +1,84 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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 args2multislice = require( '@stdlib/slice/base/args2multislice' ); +var Slice = require( '@stdlib/slice/ctor' ); +var slice = require( '@stdlib/ndarray/base/slice' ); +var nulls = require( '@stdlib/array/base/nulls' ); +var ndims = require( '@stdlib/ndarray/base/ndims' ); +var toNormalizedIndices = require( '@stdlib/ndarray/base/to-unique-normalized-indices' ); +var isIntegerArray = require( '@stdlib/assert/is-integer-array' ); +var format = require( '@stdlib/string/format' ); + + +// MAIN // + +/** +* Returns a view of an input ndarray in which the order of elements along specified dimensions is reversed. +* +* @param {ndarray} x - input array +* @param {IntegerArray} dims - indices of dimension to reverse +* @param {boolean} writable - boolean indicating whether a returned array should be writable +* @throws {TypeError} first argument must be an ndarray having one or more dimensions +* @throws {RangeError} dimension index exceeds the number of dimensions +* @returns {ndarray} ndarray view +* +* @example +* var array = require( '@stdlib/ndarray/array' ); +* +* var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] ); +* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] +* +* var y = reverseDimensions( x, [ 0, 1 ], false ); +* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ] +*/ +function reverseDimensions( x, dims, writable ) { + var args; + var N; + var d; + var i; + + // Retrieve the number of array dimensions: + N = ndims( x ); + + // Check whether we were provided a zero-dimensional array... + if ( N === 0 ) { + throw new TypeError( format( 'invalid argument. First argument must be an ndarray having one or more dimensions. Number of dimensions: %d.', N ) ); + } + // Normalize the dimension index... + d = toNormalizedIndices( dims, N-1 ); + if ( !isIntegerArray( d ) ) { + throw new RangeError( format( 'invalid argument. Dimension index exceeds the number of dimensions. Number of dimensions: %d. Value: `%s`.', N, dims ) ); + } + // Define a list of MultiSlice constructor arguments: + args = nulls( N ); + for ( i = 0; i < d.length; i++ ) { + args[ d[ i ] ] = new Slice( null, null, -1 ); + } + // Return a new array view: + return slice( x, args2multislice( args ), true, writable ); +} + + +// EXPORTS // + +module.exports = reverseDimensions; diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/package.json b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/package.json new file mode 100644 index 000000000000..dd84f701ecf3 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/package.json @@ -0,0 +1,67 @@ +{ + "name": "@stdlib/ndarray/base/reverse-dimensions", + "version": "0.0.0", + "description": "Return a view of an input ndarray in which the order of elements along specified dimensions is reversed.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdtypes", + "types", + "base", + "data", + "structure", + "vector", + "ndarray", + "matrix", + "slice", + "view", + "reverse", + "flip", + "numpy.flip" + ] +} diff --git a/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/test/test.js b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/test/test.js new file mode 100644 index 000000000000..c894a5691847 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/reverse-dimensions/test/test.js @@ -0,0 +1,593 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* 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 isndarrayLike = require( '@stdlib/assert/is-ndarray-like' ); +var isReadOnly = require( '@stdlib/ndarray/base/assert/is-read-only' ); +var zeroTo = require( '@stdlib/array/base/zero-to' ); +var typedarray = require( '@stdlib/array/typed' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var baseCtor = require( '@stdlib/ndarray/base/ctor' ); +var zeros = require( '@stdlib/ndarray/zeros' ); +var ctor = require( '@stdlib/ndarray/ctor' ); +var ndims = require( '@stdlib/ndarray/base/ndims' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var getShape = require( '@stdlib/ndarray/shape' ); +var getDType = require( '@stdlib/ndarray/dtype' ); +var getData = require( '@stdlib/ndarray/data-buffer' ); +var reverseDimensions = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof reverseDimensions, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function throws an error if provided a zero-dimensional array', function test( t ) { + var values; + var i; + + values = [ + zeros( [] ) + ]; + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error' ); + } + t.end(); + + function badValue( x ) { + return function badValue() { + reverseDimensions( x, [ 0 ], false ); + }; + } +}); + +tape( 'the function throws an error if the dimension index exceeds the number of dimensions', function test( t ) { + var values; + var i; + + values = [ + zeros( [ 1 ] ), + zeros( [ 1, 1 ] ), + zeros( [ 1, 1, 1 ] ), + zeros( [ 1, 1, 1, 1 ] ) + ]; + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ], [ 10 ] ), RangeError, 'throws an error when provided ' + values[ i ].shape.join( 'x' ) ); + t.throws( badValue( values[ i ], [ -10 ] ), RangeError, 'throws an error when provided ' + values[ i ].shape.join( 'x' ) ); + } + t.end(); + + function badValue( x, dims ) { + return function badValue() { + reverseDimensions( x, dims, false ); + }; + } +}); + +tape( 'the function returns a view of a provided input array (ndims=1)', function test( t ) { + var expected; + var actual; + var buf; + var ord; + var sh; + var st; + var o; + var x; + var i; + + buf = typedarray( zeroTo( 30 ), 'float64' ); + sh = [ 6 ]; + st = [ 2 ]; + o = 4; + ord = 'row-major'; + + x = new ctor( 'float64', buf, sh, st, o, ord ); + + actual = reverseDimensions( x, [ 0 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + + actual = reverseDimensions( x, [ -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + t.end(); +}); + +tape( 'the function returns a view of a provided input array (ndims=2)', function test( t ) { + var expected; + var actual; + var buf; + var ord; + var sh; + var st; + var o; + var x; + + buf = typedarray( zeroTo( 30 ), 'float64' ); + sh = [ 4, 3 ]; + st = [ 6, 2 ]; + o = 4; + ord = 'row-major'; + + x = new ctor( 'float64', buf, sh, st, o, ord ); + + actual = reverseDimensions( x, [ 0 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 22, 24, 26 ], + [ 16, 18, 20 ], + [ 10, 12, 14 ], + [ 4, 6, 8 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -2 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 22, 24, 26 ], + [ 16, 18, 20 ], + [ 10, 12, 14 ], + [ 4, 6, 8 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ 1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 8, 6, 4 ], + [ 14, 12, 10 ], + [ 20, 18, 16 ], + [ 26, 24, 22 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 8, 6, 4 ], + [ 14, 12, 10 ], + [ 20, 18, 16 ], + [ 26, 24, 22 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ 0, 1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 26, 24, 22 ], + [ 20, 18, 16 ], + [ 14, 12, 10 ], + [ 8, 6, 4 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -2, -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 2, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ 26, 24, 22 ], + [ 20, 18, 16 ], + [ 14, 12, 10 ], + [ 8, 6, 4 ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a view of a provided input array (ndims=3)', function test( t ) { + var expected; + var actual; + var buf; + var ord; + var sh; + var st; + var o; + var x; + + buf = typedarray( zeroTo( 100 ), 'float64' ); + sh = [ 2, 4, 3 ]; + st = [ 24, 6, 2 ]; + o = 10; + ord = 'row-major'; + + x = new ctor( 'float64', buf, sh, st, o, ord ); + + actual = reverseDimensions( x, [ 0 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 34, 36, 38 ], + [ 40, 42, 44 ], + [ 46, 48, 50 ], + [ 52, 54, 56 ] + ], + [ + [ 10, 12, 14 ], + [ 16, 18, 20 ], + [ 22, 24, 26 ], + [ 28, 30, 32 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -3 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 34, 36, 38 ], + [ 40, 42, 44 ], + [ 46, 48, 50 ], + [ 52, 54, 56 ] + ], + [ + [ 10, 12, 14 ], + [ 16, 18, 20 ], + [ 22, 24, 26 ], + [ 28, 30, 32 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ 1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 28, 30, 32 ], + [ 22, 24, 26 ], + [ 16, 18, 20 ], + [ 10, 12, 14 ] + ], + [ + [ 52, 54, 56 ], + [ 46, 48, 50 ], + [ 40, 42, 44 ], + [ 34, 36, 38 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -2 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 28, 30, 32 ], + [ 22, 24, 26 ], + [ 16, 18, 20 ], + [ 10, 12, 14 ] + ], + [ + [ 52, 54, 56 ], + [ 46, 48, 50 ], + [ 40, 42, 44 ], + [ 34, 36, 38 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ 2 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 14, 12, 10 ], + [ 20, 18, 16 ], + [ 26, 24, 22 ], + [ 32, 30, 28 ] + ], + [ + [ 38, 36, 34 ], + [ 44, 42, 40 ], + [ 50, 48, 46 ], + [ 56, 54, 52 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 14, 12, 10 ], + [ 20, 18, 16 ], + [ 26, 24, 22 ], + [ 32, 30, 28 ] + ], + [ + [ 38, 36, 34 ], + [ 44, 42, 40 ], + [ 50, 48, 46 ], + [ 56, 54, 52 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ 0, 1, 2 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 56, 54, 52 ], + [ 50, 48, 46 ], + [ 44, 42, 40 ], + [ 38, 36, 34 ] + ], + [ + [ 32, 30, 28 ], + [ 26, 24, 22 ], + [ 20, 18, 16 ], + [ 14, 12, 10 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + actual = reverseDimensions( x, [ -3, -2, -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 3, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 2, 4, 3 ], 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), true, 'returns expected value' ); + + expected = [ + [ + [ 56, 54, 52 ], + [ 50, 48, 46 ], + [ 44, 42, 40 ], + [ 38, 36, 34 ] + ], + [ + [ 32, 30, 28 ], + [ 26, 24, 22 ], + [ 20, 18, 16 ], + [ 14, 12, 10 ] + ] + ]; + actual = ndarray2array( actual ); + t.deepEqual( actual, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an ndarray having a constructor supporting read-only instances, the function supports returning a writable view (non-base, ndims=1)', function test( t ) { + var expected; + var actual; + var buf; + var ord; + var sh; + var st; + var o; + var x; + var i; + + buf = typedarray( zeroTo( 30 ), 'float64' ); + sh = [ 6 ]; + st = [ 2 ]; + o = 4; + ord = 'row-major'; + + x = new ctor( 'float64', buf, sh, st, o, ord ); + + actual = reverseDimensions( x, [ 0 ], true ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), false, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + + actual = reverseDimensions( x, [ -1 ], true ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), false, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + t.end(); +}); + +tape( 'if provided an ndarray having a constructor which does not support read-only instances, the function is not guaranteed to return either a read-only or writable view (base, ndims=1)', function test( t ) { + var expected; + var actual; + var buf; + var ord; + var sh; + var st; + var o; + var x; + var i; + + buf = typedarray( zeroTo( 30 ), 'float64' ); + sh = [ 6 ]; + st = [ 2 ]; + o = 4; + ord = 'row-major'; + + x = new baseCtor( 'float64', buf, sh, st, o, ord ); + + actual = reverseDimensions( x, [ 0 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), false, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + + actual = reverseDimensions( x, [ -1 ], false ); + + t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' ); + t.strictEqual( ndims( actual ), 1, 'returns expected value' ); + t.strictEqual( numel( getShape( x ) ), 6, 'returns expected value' ); + t.strictEqual( getDType( actual ), getDType( x ), 'returns expected value' ); + t.strictEqual( getData( actual ), getData( x ), 'returns expected value' ); + t.strictEqual( isReadOnly( actual ), false, 'returns expected value' ); + + expected = [ 14, 12, 10, 8, 6, 4 ]; + for ( i = 0; i < expected.length; i++ ) { + t.strictEqual( actual.iget( i ), expected[ i ], 'returns expected value' ); + } + t.end(); +});