From 40421e23587619a5f51af6687f94e01efb97e04b Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 17:55:39 +0000
Subject: [PATCH 01/22] feat: add ndarray/flatten-by
---
.../@stdlib/ndarray/flatten-by/README.md | 229 ++++
.../ndarray/flatten-by/benchmark/benchmark.js | 323 +++++
.../@stdlib/ndarray/flatten-by/docs/repl.txt | 50 +
.../ndarray/flatten-by/docs/types/index.d.ts | 1043 +++++++++++++++++
.../ndarray/flatten-by/docs/types/test.ts | 150 +++
.../ndarray/flatten-by/examples/index.js | 41 +
.../@stdlib/ndarray/flatten-by/lib/index.js | 54 +
.../@stdlib/ndarray/flatten-by/lib/main.js | 118 ++
.../@stdlib/ndarray/flatten-by/package.json | 65 +
.../@stdlib/ndarray/flatten-by/test/test.js | 636 ++++++++++
10 files changed, 2709 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/README.md
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/package.json
create mode 100644 lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
new file mode 100644
index 000000000000..c8ebe3392442
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -0,0 +1,229 @@
+
+
+# flattenBy
+
+> Apply a callback to elements in an input [ndarray][@stdlib/ndarray/ctor] and return a flattened output [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var flattenBy = require( '@stdlib/ndarray/flatten-by' );
+```
+
+#### flattenBy( x\[, options], fcn[, thisArg] )
+
+Applies a callback to elements in an input [ndarray][@stdlib/ndarray/ctor] and returns a flattened output [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+function scale( value ) {
+ return value * 2.0;
+}
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x, scale );
+// returns
+
+var arr = ndarray2array( y );
+// returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+```
+
+The function accepts the following arguments:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor].
+- **options**: function options (_optional_).
+- **fcn**: callback function.
+- **thisArg**: callback execution context.
+
+The function accepts the following options:
+
+- **order**: order in which input [ndarray][@stdlib/ndarray/ctor] elements should be flattened. Must be one of the following:
+
+ - `'row-major'`: flatten elements in lexicographic order. For example, given a two-dimensional input [ndarray][@stdlib/ndarray/ctor] (i.e., a matrix), flattening in lexicographic order means flattening the input [ndarray][@stdlib/ndarray/ctor] row-by-row.
+ - `'column-major'`: flatten elements in colexicographic order. For example, given a two-dimensional input [ndarray][@stdlib/ndarray/ctor] (i.e., a matrix), flattening in colexicographic order means flattening the input [ndarray][@stdlib/ndarray/ctor] column-by-column.
+ - `'any'`: flatten according to the physical layout of the input [ndarray][@stdlib/ndarray/ctor] data in memory, regardless of the stated [order][@stdlib/ndarray/orders] of the input [ndarray][@stdlib/ndarray/ctor].
+ - `'same'`: flatten according to the stated [order][@stdlib/ndarray/orders] of the input [ndarray][@stdlib/ndarray/ctor].
+
+ Default: `'row-major'`.
+
+- **depth**: maximum number of input [ndarray][@stdlib/ndarray/ctor] dimensions to flatten.
+
+By default, the function flattens all dimensions of the input [ndarray][@stdlib/ndarray/ctor]. To flatten to a desired depth, specify the `depth` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+function scale( value ) {
+ return value * 2.0;
+}
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x, {
+ 'depth': 1
+});
+// returns
+
+var arr = ndarray2array( y );
+// returns [ [ 2.0, 4.0 ], [ 6.0, 8.0 ], [ 10.0, 12.0 ] ]
+```
+
+By default, the input [ndarray][@stdlib/ndarray/ctor] is flattened in lexicographic order. To flatten elements in a different order, specify the `order` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+function scale( value ) {
+ return value * 2.0;
+}
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x, {
+ 'order': 'column-major'
+});
+// returns
+
+var arr = ndarray2array( y );
+// returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+```
+
+To set the callback function execution context, provide a `thisArg`.
+
+
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+function scale( value ) {
+ this.count += 1;
+ return value * 2.0;
+}
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var ctx = {
+ 'count': 0
+};
+
+var y = flatten( x, scale, ctx );
+// returns
+
+var arr = ndarray2array( y );
+// returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+
+var count = ctx.count;
+// returns 6
+```
+
+
+
+
+
+
+
+## Notes
+
+- The function **always** returns a copy of input [ndarray][@stdlib/ndarray/ctor] data, even when an input [ndarray][@stdlib/ndarray/ctor] already has the desired number of dimensions.
+
+- The callback function is provided the following arguments:
+
+ - **value**: current array element.
+ - **indices**: current array element indices.
+ - **arr**: the input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flattenBy = require( '@stdlib/ndarray/flatten-by' );
+
+function scale( value ) {
+ return value * 2.0;
+}
+
+var xbuf = discreteUniform( 12, -100, 100, {
+ 'dtype': 'generic'
+});
+
+var x = array( xbuf, {
+ 'shape': [ 2, 2, 3 ],
+ 'dtype': 'generic'
+});
+console.log( ndarray2array( x ) );
+
+var y = flatten( x, scale );
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/orders]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/orders
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
new file mode 100644
index 000000000000..3a944024eb6a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
@@ -0,0 +1,323 @@
+/**
+* @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 bench = require( '@stdlib/bench' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var zeros = require( '@stdlib/ndarray/base/zeros' );
+var pkg = require( './../package.json' ).name;
+var flattenBy = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Callback function.
+*
+* @param {number} value - current value
+* @returns {number} output value
+*/
+function clbk( value ) {
+ return value + 1;
+}
+
+
+// MAIN //
+
+bench( pkg+'::2d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 10, 10 ], 'row-major' ),
+ zeros( 'float32', [ 10, 10 ], 'row-major' ),
+ zeros( 'int32', [ 10, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 10, 10 ], 'row-major' ),
+ zeros( 'generic', [ 10, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::2d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 10, 10 ], 'row-major' ),
+ zeros( 'float32', [ 10, 10 ], 'row-major' ),
+ zeros( 'int32', [ 10, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 10, 10 ], 'row-major' ),
+ zeros( 'generic', [ 10, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 1,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::3d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 2,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::3d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 2,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::4d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 3,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::4d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 3,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::5d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 4,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::5d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 4,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flattenBy( values[ j ], opts, clbk );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
new file mode 100644
index 000000000000..b760777e183a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
@@ -0,0 +1,50 @@
+
+{{alias}}( x[, options], fcn[, thisArg] )
+ Applies a callback to elements in an input ndarray and returns a flattened
+ output ndarray.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input ndarray.
+
+ options: Object (optional)
+ Function options.
+
+ options.depth: integer (optional)
+ Maximum number of dimensions to flatten. By default, the function
+ flattens all input ndarray dimensions.
+
+ options.order: string (optional)
+ Order in which input ndarray elements should be flattened. The following
+ orders are supported:
+
+ - row-major: flatten in lexicographic order.
+ - column-major: flatten in colexicographic order.
+ - same: flatten according to the stated order of the input ndarray.
+ - any: flatten according to physical layout of the input ndarray data in
+ memory, regardless of the stated order of the input ndarray.
+
+ Default: 'row-major'.
+
+ fcn: Function
+ Callback function.
+
+ thisArg: any (optional)
+ Callback execution context.
+
+ Returns
+ -------
+ out: ndarray
+ Output ndarray.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+ > function f ( v ) { return v * 2.0 };
+ > var y = {{alias}}( x, f );
+ > var arr = {{alias:@stdlib/ndarray/to-array}}( y )
+ [ 2.0, 4.0, 6.0, 8.0 ]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
new file mode 100644
index 000000000000..dd01fd443d0e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
@@ -0,0 +1,1043 @@
+/*
+* @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.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { float64ndarray, float32ndarray, complex128ndarray, complex64ndarray, int32ndarray, int16ndarray, int8ndarray, uint32ndarray, uint16ndarray, uint8ndarray, uint8cndarray, boolndarray, genericndarray, Order } from '@stdlib/types/ndarray';
+import { Complex64, Complex128, ComplexLike } from '@stdlib/types/complex';
+
+/**
+* Callback invoked for each ndarray element.
+*
+* @returns output value
+*/
+type Nullary = ( this: W ) => V;
+
+/**
+* Callback invoked for each ndarray element.
+*
+* @param value - current array element
+* @returns output value
+*/
+type Unary = ( this: W, value: T ) => V;
+
+/**
+* Callback invoked for each ndarray element.
+*
+* @param value - current array element
+* @param indices - current array element indices
+* @returns output value
+*/
+type Binary = ( this: W, value: T, indices: Array ) => V;
+
+/**
+* Callback invoked for each ndarray element.
+*
+* @param value - current array element
+* @param indices - current array element indices
+* @param arr - input array
+* @returns output value
+*/
+type Ternary = ( this: W, value: T, indices: Array, arr: U ) => V;
+
+/**
+* Callback invoked for each ndarray element.
+*
+* @param value - current array element
+* @param indices - current array element indices
+* @param arr - input array
+* @returns output value
+*/
+type Callback = Nullary | Unary | Binary | Ternary;
+
+/**
+* Interface defining function options.
+*/
+interface Options {
+ /**
+ * Maximum number of dimensions to flatten.
+ *
+ * ## Notes
+ *
+ * - By default, the function flattens all input ndarray dimensions.
+ */
+ depth?: number;
+
+ /**
+ * Order in which input ndarray elements should be flattened.
+ *
+ * ## Notes
+ *
+ * - The following orders are supported:
+ *
+ * - **row-major**: flatten in lexicographic order.
+ * - **column-major**: flatten in colexicographic order.
+ * - **same**: flatten according to the stated order of the input ndarray.
+ * - **any**: flatten according to the physical layout of the input ndarray data in memory, regardless of the stated order of the input ndarray.
+ *
+ * - Default: 'row-major'.
+ */
+ order?: Order | 'same' | 'any';
+}
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+*/
+declare function flattenBy( x: float64ndarray, fcn: Callback, thisArg?: ThisParameterType> ): float64ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'float32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+*/
+declare function flattenBy( x: float32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): float32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function identity( value ) {
+* return value;
+* }
+*
+* var buffer = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 1 , 3 ];
+* var strides = [ 3, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'complex64', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, identity );
+* // returns
+*/
+declare function flattenBy( x: complex64ndarray, fcn: Callback, thisArg?: ThisParameterType> ): complex64ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function identity( value ) {
+* return value;
+* }
+*
+* var buffer = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 1 , 3 ];
+* var strides = [ 3, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'complex128', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, identity );
+* // returns
+*/
+declare function flattenBy( x: complex128ndarray, fcn: Callback, thisArg?: ThisParameterType> ): complex128ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int32Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: int32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int16Array = require( '@stdlib/array/int32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int16Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int16', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: int16ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int16ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int8Array = require( '@stdlib/array/int8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int8Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int8', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: int8ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int8ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint32Array = require( '@stdlib/array/uint32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint32Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: uint32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint16Array = require( '@stdlib/array/uint16' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint16Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint16', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: uint16ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint16ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint8Array = require( '@stdlib/array/uint8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint8Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: uint8ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint8ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint8ClampedArray = require( '@stdlib/array/uint8c' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint8ClampedArray( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8c', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2, 4, 6, 8, 10, 12 ]
+*/
+declare function flattenBy( x: uint8cndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint8cndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var BooleanArray = require( '@stdlib/array/bool' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function invert( value ) {
+* return !value;
+* }
+*
+* var buffer = new BooleanArray( [ true, false, true, false, true, false ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8c', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ false, true, false, true, false, true ]
+*/
+declare function flattenBy( x: boolndarray, fcn: Callback, thisArg?: ThisParameterType> ): boolndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+*/
+declare function flattenBy( x: genericndarray, fcn: Callback, V, W>, thisArg?: ThisParameterType, V, W>> ): genericndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2.0, 4.0, 6.0 ], [ 8.0, 10.0, 12.0 ] ]
+*/
+declare function flattenBy( x: float64ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): float64ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'float32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2.0, 4.0, 6.0 ], [ 8.0, 10.0, 12.0 ] ]
+*/
+declare function flattenBy( x: float32ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): float32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function identity( value ) {
+* return value;
+* }
+*
+* var buffer = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 1 , 3 ];
+* var strides = [ 3, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'complex64', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, identity );
+* // returns
+*/
+declare function flattenBy( x: complex64ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): complex64ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function identity( value ) {
+* return value;
+* }
+*
+* var buffer = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var shape = [ 1 , 3 ];
+* var strides = [ 3, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'complex128', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, identity );
+* // returns
+*/
+declare function flattenBy( x: complex128ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): complex128ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int32Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: int32ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): int32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int16Array = require( '@stdlib/array/int32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int16Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int16', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: int16ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): int16ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Int8Array = require( '@stdlib/array/int8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Int8Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'int8', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: int8ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): int8ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint32Array = require( '@stdlib/array/uint32' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint32Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint32', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: uint32ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): uint32ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint16Array = require( '@stdlib/array/uint16' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint16Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint16', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: uint16ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): uint16ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint8Array = require( '@stdlib/array/uint8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint8Array( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: uint8ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): uint8ndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var Uint8ClampedArray = require( '@stdlib/array/uint8c' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = new Uint8ClampedArray( [ 1, 2, 3, 4, 5, 6 ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8c', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2, 4, 6 ], [ 8, 10, 12 ] ]
+*/
+declare function flattenBy( x: uint8cndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): uint8cndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var BooleanArray = require( '@stdlib/array/bool' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function invert( value ) {
+* return !value;
+* }
+*
+* var buffer = new BooleanArray( [ true, false, true, false, true, false ] );
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'uint8c', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ false, true, false, true, false, true ]
+*/
+declare function flattenBy( x: boolndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): boolndarray;
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @param fcn - callback function
+* @param thisArg - callback execution context
+* @returns output ndarray
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+* var shape = [ 3, 1, 2 ];
+* var strides = [ 2, 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+* // return
+*
+* var opts = {
+* 'depth': 1
+* };
+*
+* var y = flattenBy( x, opts, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 2.0, 4.0, 6.0 ], [ 8.0, 10.0, 12.0 ] ]
+*/
+declare function flattenBy( x: genericndarray, options: Options, fcn: Callback, V, W>, thisArg?: ThisParameterType, V, W>> ): genericndarray;
+
+// EXPORTS //
+
+export = flattenBy;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
new file mode 100644
index 000000000000..a9ed59eef273
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
@@ -0,0 +1,150 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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 zeros = require( '@stdlib/ndarray/base/zeros' );
+import flattenBy = require( './index' );
+
+/**
+* Evaluates the identity function.
+*
+* @param x - input value
+* @returns input value
+*/
+function identity( x: any ): any {
+ return x;
+}
+
+// The function returns an ndarray...
+{
+ const sh = [ 2, 2 ];
+ const ord = 'row-major';
+
+ flattenBy( zeros( 'float64', sh, ord ), identity ); // $ExpectType float64ndarray
+ flattenBy( zeros( 'float64', sh, ord ), {}, identity ); // $ExpectType float64ndarray
+ flattenBy( zeros( 'float64', sh, ord ), identity, {} ); // $ExpectType float64ndarray
+ flattenBy( zeros( 'float64', sh, ord ), {}, identity, {} ); // $ExpectType float64ndarray
+ flattenBy( zeros( 'float32', sh, ord ), identity ); // $ExpectType float32ndarray
+ flattenBy( zeros( 'float32', sh, ord ), {}, identity ); // $ExpectType float32ndarray
+ flattenBy( zeros( 'float32', sh, ord ), identity, {} ); // $ExpectType float32ndarray
+ flattenBy( zeros( 'float32', sh, ord ), {}, identity, {} ); // $ExpectType float32ndarray
+ flattenBy( zeros( 'complex64', sh, ord ), identity ); // $ExpectType complex64ndarray
+ flattenBy( zeros( 'complex64', sh, ord ), {}, identity ); // $ExpectType complex64ndarray
+ flattenBy( zeros( 'complex64', sh, ord ), identity, {} ); // $ExpectType complex64ndarray
+ flattenBy( zeros( 'complex64', sh, ord ), {}, identity, {} ); // $ExpectType complex64ndarray
+ flattenBy( zeros( 'complex128', sh, ord ), identity ); // $ExpectType complex128ndarray
+ flattenBy( zeros( 'complex128', sh, ord ), {}, identity ); // $ExpectType complex128ndarray
+ flattenBy( zeros( 'complex128', sh, ord ), identity, {} ); // $ExpectType complex128ndarray
+ flattenBy( zeros( 'complex128', sh, ord ), {}, identity, {} ); // $ExpectType complex128ndarray
+ flattenBy( zeros( 'int32', sh, ord ), identity ); // $ExpectType int32ndarray
+ flattenBy( zeros( 'int32', sh, ord ), {}, identity ); // $ExpectType int32ndarray
+ flattenBy( zeros( 'int32', sh, ord ), identity, {} ); // $ExpectType int32ndarray
+ flattenBy( zeros( 'int32', sh, ord ), {}, identity, {} ); // $ExpectType int32ndarray
+ flattenBy( zeros( 'int16', sh, ord ), identity ); // $ExpectType int16ndarray
+ flattenBy( zeros( 'int16', sh, ord ), {}, identity ); // $ExpectType int16ndarray
+ flattenBy( zeros( 'int16', sh, ord ), identity, {} ); // $ExpectType int16ndarray
+ flattenBy( zeros( 'int16', sh, ord ), {}, identity, {} ); // $ExpectType int16ndarray
+ flattenBy( zeros( 'int8', sh, ord ), identity ); // $ExpectType int8ndarray
+ flattenBy( zeros( 'int8', sh, ord ), {}, identity ); // $ExpectType int8ndarray
+ flattenBy( zeros( 'int8', sh, ord ), identity, {} ); // $ExpectType int8ndarray
+ flattenBy( zeros( 'int8', sh, ord ), {}, identity, {} ); // $ExpectType int8ndarray
+ flattenBy( zeros( 'uint32', sh, ord ), identity ); // $ExpectType uint32ndarray
+ flattenBy( zeros( 'uint32', sh, ord ), {}, identity ); // $ExpectType uint32ndarray
+ flattenBy( zeros( 'uint32', sh, ord ), identity, {} ); // $ExpectType uint32ndarray
+ flattenBy( zeros( 'uint16', sh, ord ), identity ); // $ExpectType uint16ndarray
+ flattenBy( zeros( 'uint16', sh, ord ), {}, identity ); // $ExpectType uint16ndarray
+ flattenBy( zeros( 'uint16', sh, ord ), identity, {} ); // $ExpectType uint16ndarray
+ flattenBy( zeros( 'uint16', sh, ord ), {}, identity, {} ); // $ExpectType uint16ndarray
+ flattenBy( zeros( 'uint8', sh, ord ), identity ); // $ExpectType uint8ndarray
+ flattenBy( zeros( 'uint8', sh, ord ), {}, identity ); // $ExpectType uint8ndarray
+ flattenBy( zeros( 'uint8', sh, ord ), identity, {} ); // $ExpectType uint8ndarray
+ flattenBy( zeros( 'uint8', sh, ord ), {}, identity, {} ); // $ExpectType uint8ndarray
+ flattenBy( zeros( 'uint8c', sh, ord ), identity ); // $ExpectType uint8cndarray
+ flattenBy( zeros( 'uint8c', sh, ord ), {}, identity ); // $ExpectType uint8cndarray
+ flattenBy( zeros( 'uint8c', sh, ord ), identity, {} ); // $ExpectType uint8cndarray
+ flattenBy( zeros( 'uint8c', sh, ord ), {}, identity, {} ); // $ExpectType uint8cndarray
+ flattenBy( empty( 'bool', sh, ord ), identity ); // $ExpectType boolndarray
+ flattenBy( empty( 'bool', sh, ord ), {}, identity ); // $ExpectType boolndarray
+ flattenBy( empty( 'bool', sh, ord ), identity, {} ); // $ExpectType boolndarray
+ flattenBy( empty( 'bool', sh, ord ), {}, identity, {} ); // $ExpectType boolndarray
+ flattenBy( zeros( 'generic', sh, ord ), identity ); // $ExpectType genericndarray
+ flattenBy( zeros( 'generic', sh, ord ), {}, identity ); // $ExpectType genericndarray
+ flattenBy( zeros( 'generic', sh, ord ), identity, {} ); // $ExpectType genericndarray
+ flattenBy( zeros( 'generic', sh, ord ), {}, identity, {} ); // $ExpectType genericndarray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ flattenBy( 5, identity ); // $ExpectError
+ flattenBy( true, identity ); // $ExpectError
+ flattenBy( false, identity ); // $ExpectError
+ flattenBy( null, identity ); // $ExpectError
+ flattenBy( undefined, identity ); // $ExpectError
+ flattenBy( {}, identity ); // $ExpectError
+ flattenBy( [ 1 ], identity ); // $ExpectError
+ flattenBy( ( x: number ): number => x, identity ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an options argument which is not an object...
+{
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), '5', identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), true, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), false, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), null, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), [ 1 ], identity ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument with invalid `depth` option...
+{
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': '5' }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': true }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': false }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': null }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': [ 1 ] }, identity ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument with invalid `order` option...
+{
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': '5' }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': true }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': false }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': null }, identity ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': [ 1 ] }, identity ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a callback which is not a function...
+{
+ const x = zeros( 'generic', [ 2, 2 ], 'row-major' );
+
+ flattenBy( x, {}, '5' ); // $ExpectError
+ flattenBy( x, {}, true ); // $ExpectError
+ flattenBy( x, {}, false ); // $ExpectError
+ flattenBy( x, {}, null ); // $ExpectError
+ flattenBy( x, {}, undefined ); // $ExpectError
+ flattenBy( x, {}, {} ); // $ExpectError
+ flattenBy( x, {}, [ 1 ] ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ flattenBy(); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2 ], 'row-major' ) ); // $ExpectError
+ flattenBy( zeros( 'float64', [ 2, 2 ], 'row-major' ), {}, ( x: number ): number => x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js b/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
new file mode 100644
index 000000000000..e55d817ec277
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flattenBy = require( './../lib' );
+
+function scale( value ) {
+ return value * 2.0;
+}
+
+var xbuf = discreteUniform( 12, -100, 100, {
+ 'dtype': 'generic'
+});
+
+var x = array( xbuf, {
+ 'shape': [ 2, 2, 3 ],
+ 'dtype': 'generic'
+});
+console.log( ndarray2array( x ) );
+
+var y = flattenBy( x, scale );
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
new file mode 100644
index 000000000000..3707dae03068
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
@@ -0,0 +1,54 @@
+/**
+* @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';
+
+/**
+* Apply a callback to elements in an input ndarray and return a flattened output ndarray.
+*
+* @module @stdlib/ndarray/flatten-by
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+* var flattenBy = require( '@stdlib/ndarray/flatten-by' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* // Create an input ndarray:
+* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+* // return
+*
+* // Flatten the input ndarray:
+* var y = flatten( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js
new file mode 100644
index 000000000000..f5ca1ecd0b6d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.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 isPlainObject = require( '@stdlib/assert/is-plain-object' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isNonNegativeInteger = require( '@stdlib/assert/is-nonnegative-integer' );
+var isOrder = require( '@stdlib/ndarray/base/assert/is-order' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var getStrides = require( '@stdlib/ndarray/strides' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var getDType = require( '@stdlib/ndarray/base/dtype' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2order = require( '@stdlib/ndarray/base/strides2order' );
+var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
+var assign = require( '@stdlib/ndarray/base/assign' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var map = require( '@stdlib/ndarray/map' );
+var flatten = require( '@stdlib/ndarray/flatten' );
+var format = require( '@stdlib/string/format' );
+
+
+// MAIN //
+
+/**
+* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+*
+* @param {ndarray} x - input ndarray
+* @param {Options} [options] - function options
+* @param {NonNegativeInteger} [options.depth] - maximum number of dimensions to flatten
+* @param {string} [options.order='row-major'] - order in which input ndarray elements should be flattened
+* @param {Function} fcn - callback function
+* @param {*} thisArg - callback execution context
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {TypeError} callback argument must be a function
+* @throws {TypeError} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* function scale( value ) {
+* return value * 2.0;
+* }
+*
+* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+* // return
+*
+* var y = flattenBy( x, scale );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+*/
+function flattenBy( x, options, fcn, thisArg ) {
+ var opts;
+ var ctx;
+ var cb;
+ var y;
+
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ opts = {};
+ if ( arguments.length < 3 ) { // Case: flattenBy( x, fcn )
+ cb = options;
+ } else if ( arguments.length === 3 ) {
+ if ( isFunction( options ) ) { // Case: flattenBy( x, fcn, thisArg )
+ cb = options;
+ ctx = fcn;
+ } else { // Case: flattenBy( x, options, fcn )
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ opts = options;
+ cb = fcn;
+ }
+ } else {
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ opts = options;
+ cb = fcn;
+ ctx = thisArg;
+ }
+ if ( !isFunction( cb ) ) {
+ throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', cb ) );
+ }
+ y = map( x, cb, ctx );
+ return flatten( y, opts );
+}
+
+
+// EXPORTS //
+
+module.exports = flattenBy;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/package.json b/lib/node_modules/@stdlib/ndarray/flatten-by/package.json
new file mode 100644
index 000000000000..6710105cdaca
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "@stdlib/ndarray/flatten-by",
+ "version": "0.0.0",
+ "description": "Apply a callback to elements in an input ndarray and return a flattened output ndarray.",
+ "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",
+ "multidimensional",
+ "array",
+ "ndarray",
+ "tensor",
+ "matrix",
+ "flat",
+ "flatten",
+ "map",
+ "copy",
+ "transform"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js b/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
new file mode 100644
index 000000000000..9b18074ece84
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
@@ -0,0 +1,636 @@
+/**
+* @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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var Float64Array = require( '@stdlib/array/float64' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flattenBy = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Callback function.
+*
+* @param value - current value
+* @returns output value
+*/
+function clbk( value ) {
+ return value + 1;
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof flattenBy, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( value, clbk );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( value, {}, clbk );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an options argument which is not an object', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( zeros( [ 2, 2, 2 ] ), value, clbk );
+ };
+ }
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, non-contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 8, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 2.0, NaN, 3.0, NaN, 4.0, NaN, 5.0, NaN, 6.0, NaN, 7.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, non-contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 2, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 5.0, NaN, 3.0, NaN, 7.0, NaN, 2.0, NaN, 6.0, NaN, 4.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the maximum number of dimensions to flatten (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'depth': 0
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ]
+ ],
+ [
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 2
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the maximum number of dimensions to flatten (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'depth': 0
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ]
+ ],
+ [
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 2
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in lexicographic order (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in lexicographic order (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
From 5a11ffb9884e31eb3e4ba61586bfbafd8f39f733 Mon Sep 17 00:00:00 2001
From: headlessNode
Date: Sun, 14 Sep 2025 23:42:11 +0500
Subject: [PATCH 02/22] refactor: apply suggestions from code review
---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
- task: lint_filenames
status: passed
- task: lint_editorconfig
status: passed
- task: lint_markdown
status: na
- task: lint_package_json
status: na
- task: lint_repl_help
status: na
- task: lint_javascript_src
status: passed
- task: lint_javascript_cli
status: na
- task: lint_javascript_examples
status: passed
- task: lint_javascript_tests
status: passed
- task: lint_javascript_benchmarks
status: na
- task: lint_python
status: na
- task: lint_r
status: na
- task: lint_c_src
status: na
- task: lint_c_examples
status: na
- task: lint_c_benchmarks
status: na
- task: lint_c_tests_fixtures
status: na
- task: lint_shell
status: na
- task: lint_typescript_declarations
status: na
- task: lint_typescript_tests
status: na
- task: lint_license_headers
status: passed
---
---
.../ndarray/flatten-by/examples/index.js | 2 +-
.../@stdlib/ndarray/flatten-by/lib/index.js | 3 +-
.../@stdlib/ndarray/flatten-by/lib/main.js | 32 +-
.../@stdlib/ndarray/flatten-by/test/test.js | 1370 ++++++++++-------
4 files changed, 832 insertions(+), 575 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js b/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
index e55d817ec277..d99b9ccc65e3 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/examples/index.js
@@ -24,7 +24,7 @@ var ndarray2array = require( '@stdlib/ndarray/to-array' );
var flattenBy = require( './../lib' );
function scale( value ) {
- return value * 2.0;
+ return value * 2.0;
}
var xbuf = discreteUniform( 12, -100, 100, {
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
index 3707dae03068..e5d9dea50188 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/index.js
@@ -36,8 +36,7 @@
* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
* // return
*
-* // Flatten the input ndarray:
-* var y = flatten( x, scale );
+* var y = flattenBy( x, scale );
* // returns
*
* var arr = ndarray2array( y );
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js
index f5ca1ecd0b6d..f101d4925ca7 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/lib/main.js
@@ -21,20 +21,8 @@
// MODULES //
var isPlainObject = require( '@stdlib/assert/is-plain-object' );
-var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isFunction = require( '@stdlib/assert/is-function' );
var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
-var isNonNegativeInteger = require( '@stdlib/assert/is-nonnegative-integer' );
-var isOrder = require( '@stdlib/ndarray/base/assert/is-order' );
-var getShape = require( '@stdlib/ndarray/shape' );
-var getOrder = require( '@stdlib/ndarray/order' );
-var getStrides = require( '@stdlib/ndarray/strides' );
-var getData = require( '@stdlib/ndarray/base/data-buffer' );
-var getDType = require( '@stdlib/ndarray/base/dtype' );
-var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
-var strides2order = require( '@stdlib/ndarray/base/strides2order' );
-var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
-var assign = require( '@stdlib/ndarray/base/assign' );
-var emptyLike = require( '@stdlib/ndarray/empty-like' );
var map = require( '@stdlib/ndarray/map' );
var flatten = require( '@stdlib/ndarray/flatten' );
var format = require( '@stdlib/string/format' );
@@ -80,10 +68,10 @@ function flattenBy( x, options, fcn, thisArg ) {
var cb;
var y;
- if ( !isndarrayLike( x ) ) {
+ if ( !isndarrayLike( x ) ) {
throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
}
- opts = {};
+ opts = {};
if ( arguments.length < 3 ) { // Case: flattenBy( x, fcn )
cb = options;
} else if ( arguments.length === 3 ) {
@@ -91,16 +79,16 @@ function flattenBy( x, options, fcn, thisArg ) {
cb = options;
ctx = fcn;
} else { // Case: flattenBy( x, options, fcn )
- if ( !isPlainObject( options ) ) {
- throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
- }
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
opts = options;
cb = fcn;
}
} else {
- if ( !isPlainObject( options ) ) {
- throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
- }
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
opts = options;
cb = fcn;
ctx = thisArg;
@@ -108,7 +96,7 @@ function flattenBy( x, options, fcn, thisArg ) {
if ( !isFunction( cb ) ) {
throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', cb ) );
}
- y = map( x, cb, ctx );
+ y = map( x, cb, ctx );
return flatten( y, opts );
}
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js b/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
index 9b18074ece84..376bb2af2b73 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/test/test.js
@@ -33,7 +33,6 @@ var getOrder = require( '@stdlib/ndarray/order' );
var getData = require( '@stdlib/ndarray/data-buffer' );
var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
-var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
var ndarray2array = require( '@stdlib/ndarray/to-array' );
var flattenBy = require( './../lib' );
@@ -43,594 +42,865 @@ var flattenBy = require( './../lib' );
/**
* Callback function.
*
-* @param value - current value
-* @returns output value
+* @param {number} value - current value
+* @returns {number} output value
*/
function clbk( value ) {
- return value + 1;
+ return value + 1;
}
// TESTS //
tape( 'main export is a function', function test( t ) {
- t.ok( true, __filename );
- t.strictEqual( typeof flattenBy, 'function', 'main export is a function' );
- t.end();
+ t.ok( true, __filename );
+ t.strictEqual( typeof flattenBy, 'function', 'main export is a function' );
+ t.end();
});
tape( 'the function throws an error if provided a first argument which is not an ndarray', function test( t ) {
- var values;
- var i;
-
- values = [
- '5',
- 5,
- NaN,
- true,
- false,
- null,
- void 0,
- [],
- {},
- function noop() {}
- ];
- for ( i = 0; i < values.length; i++ ) {
- t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
- }
- t.end();
-
- function badValue( value ) {
- return function badValue() {
- flattenBy( value, clbk );
- };
- }
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( value, clbk );
+ };
+ }
});
tape( 'the function throws an error if provided a first argument which is not an ndarray (options)', function test( t ) {
- var values;
- var i;
-
- values = [
- '5',
- 5,
- NaN,
- true,
- false,
- null,
- void 0,
- [],
- {},
- function noop() {}
- ];
- for ( i = 0; i < values.length; i++ ) {
- t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
- }
- t.end();
-
- function badValue( value ) {
- return function badValue() {
- flattenBy( value, {}, clbk );
- };
- }
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( value, {}, clbk );
+ };
+ }
});
tape( 'the function throws an error if provided an options argument which is not an object', function test( t ) {
- var values;
- var i;
-
- values = [
- '5',
- 5,
- NaN,
- true,
- false,
- null,
- void 0,
- function noop() {}
- ];
- for ( i = 0; i < values.length; i++ ) {
- t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
- }
- t.end();
-
- function badValue( value ) {
- return function badValue() {
- flattenBy( zeros( [ 2, 2, 2 ] ), value, clbk );
- };
- }
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flattenBy( zeros( [ 2, 2, 2 ] ), value, clbk );
+ };
+ }
});
tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, contiguous)', function test( t ) {
- var expected;
- var xbuf;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'row-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- y = flattenBy( x, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, non-contiguous)', function test( t ) {
- var expected;
- var xbuf;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'row-major';
- sh = [ 2, 2, 2 ];
- st = [ 8, 4, 2 ];
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, NaN, 2.0, NaN, 3.0, NaN, 4.0, NaN, 5.0, NaN, 6.0, NaN, 7.0, NaN, 8.0, NaN ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- y = flattenBy( x, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 8, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 2.0, NaN, 3.0, NaN, 4.0, NaN, 5.0, NaN, 6.0, NaN, 7.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, contiguous)', function test( t ) {
- var expected;
- var xbuf;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'column-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- y = flattenBy( x, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, non-contiguous)', function test( t ) {
- var expected;
- var xbuf;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'column-major';
- sh = [ 2, 2, 2 ];
- st = [ 2, 4, 8 ];
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, NaN, 5.0, NaN, 3.0, NaN, 7.0, NaN, 2.0, NaN, 6.0, NaN, 4.0, NaN, 8.0, NaN ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- y = flattenBy( x, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 2, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 5.0, NaN, 3.0, NaN, 7.0, NaN, 2.0, NaN, 6.0, NaN, 4.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flattenBy( x, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'the function supports specifying the maximum number of dimensions to flatten (row-major)', function test( t ) {
- var expected;
- var xbuf;
- var opts;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'row-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- opts = {
- 'depth': 0
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ]
- ],
- [
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 1
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ],
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 2
- };
- y = flattenBy( x, opts, clbk );
- expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'depth': 0
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ]
+ ],
+ [
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 2
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'the function supports specifying the maximum number of dimensions to flatten (column-major)', function test( t ) {
- var expected;
- var xbuf;
- var opts;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'column-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- opts = {
- 'depth': 0
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ]
- ],
- [
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 1
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ],
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 2
- };
- y = flattenBy( x, opts, clbk );
- expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'depth': 0
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ]
+ ],
+ [
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 2
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'the function supports flattening a provided input ndarray in lexicographic order (row-major)', function test( t ) {
- var expected;
- var xbuf;
- var opts;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'row-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- opts = {
- 'order': 'row-major'
- };
- y = flattenBy( x, opts, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 1,
- 'order': 'row-major'
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ],
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
});
tape( 'the function supports flattening a provided input ndarray in lexicographic order (column-major)', function test( t ) {
- var expected;
- var xbuf;
- var opts;
- var ord;
- var sh;
- var st;
- var dt;
- var o;
- var x;
- var y;
-
- dt = 'float64';
- ord = 'column-major';
- sh = [ 2, 2, 2 ];
- st = shape2strides( sh, ord );
- o = strides2offset( sh, st );
-
- /*
- * [
- * [
- * [ 1.0, 2.0 ],
- * [ 3.0, 4.0 ]
- * ],
- * [
- * [ 5.0, 6.0 ],
- * [ 7.0, 8.0 ]
- * ]
- * ]
- */
- xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
- x = new ndarray( dt, xbuf, sh, st, o, ord );
-
- opts = {
- 'order': 'row-major'
- };
- y = flattenBy( x, opts, clbk );
- expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- opts = {
- 'depth': 1,
- 'order': 'row-major'
- };
- y = flattenBy( x, opts, clbk );
- expected = [
- [ 2.0, 3.0 ],
- [ 4.0, 5.0 ],
- [ 6.0, 7.0 ],
- [ 8.0, 9.0 ]
- ];
-
- t.notEqual( y, x, 'returns expected value' );
- t.notEqual( getData( y ), xbuf, 'returns expected value' );
- t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
- t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
- t.strictEqual( getDType( y ), dt, 'returns expected value' );
- t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
-
- t.end();
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in colexicographic order (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'column-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 6.0, 4.0, 8.0, 3.0, 7.0, 5.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'column-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 6.0, 7.0 ],
+ [ 4.0, 5.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in colexicographic order (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'column-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 6.0, 4.0, 8.0, 3.0, 7.0, 5.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'column-major'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 6.0, 7.0 ],
+ [ 4.0, 5.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in same order as the input ndarray (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'same'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'same'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 4.0, 5.0 ],
+ [ 6.0, 7.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in same order as the input ndarray (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var opts;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ opts = {
+ 'order': 'same'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = new Float64Array( [ 2.0, 6.0, 4.0, 8.0, 3.0, 7.0, 5.0, 9.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ opts = {
+ 'depth': 1,
+ 'order': 'same'
+ };
+ y = flattenBy( x, opts, clbk );
+ expected = [
+ [ 2.0, 3.0 ],
+ [ 6.0, 7.0 ],
+ [ 4.0, 5.0 ],
+ [ 8.0, 9.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
});
From d8b8cdbab63b71bb13b6498ac68df390f8c2aeb1 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 23:49:35 +0500
Subject: [PATCH 03/22] docs: apply review suggestion
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
index a9ed59eef273..0c2812f0f983 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/test.ts
@@ -1,7 +1,7 @@
/*
* @license Apache-2.0
*
-* Copyright (c) 2024 The Stdlib Authors.
+* 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.
From 5465edd0a8fba991f1f32e7486d40ba5b7dc1c76 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 23:56:40 +0500
Subject: [PATCH 04/22] docs: apply suggestions from code review
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
.../@stdlib/ndarray/flatten-by/README.md | 21 +++++++++++--------
1 file changed, 12 insertions(+), 9 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
index c8ebe3392442..8212b67a1f45 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -51,7 +51,7 @@ function scale( value ) {
var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
// returns
-var y = flatten( x, scale );
+var y = flattenBy( x, scale );
// returns
var arr = ndarray2array( y );
@@ -91,9 +91,10 @@ function scale( value ) {
var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
// returns
-var y = flatten( x, {
- 'depth': 1
-});
+var opts = {
+ 'depth: 1
+};
+var y = flatten( x, opts, scale );
// returns
var arr = ndarray2array( y );
@@ -113,9 +114,11 @@ function scale( value ) {
var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
// returns
-var y = flatten( x, {
- 'order': 'column-major'
-});
+var opts = {
+ 'order': 'column-major'
+};
+
+var y = flatten( x, opts, scale );
// returns
var arr = ndarray2array( y );
@@ -142,7 +145,7 @@ var ctx = {
'count': 0
};
-var y = flatten( x, scale, ctx );
+var y = flattenBy( x, scale, ctx );
// returns
var arr = ndarray2array( y );
@@ -198,7 +201,7 @@ var x = array( xbuf, {
});
console.log( ndarray2array( x ) );
-var y = flatten( x, scale );
+var y = flattenBy( x, scale );
console.log( ndarray2array( y ) );
```
From aea5ad2a27d6ebb0ba807ef325fa72851e12227c Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 23:59:54 +0500
Subject: [PATCH 05/22] refactor: apply suggestions from code review
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
.../@stdlib/ndarray/flatten-by/benchmark/benchmark.js | 8 --------
1 file changed, 8 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
index 3a944024eb6a..857667a08525 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/benchmark/benchmark.js
@@ -53,7 +53,6 @@ bench( pkg+'::2d:row-major', function benchmark( b ) {
zeros( 'float64', [ 10, 10 ], 'row-major' ),
zeros( 'float32', [ 10, 10 ], 'row-major' ),
zeros( 'int32', [ 10, 10 ], 'row-major' ),
- zeros( 'complex128', [ 10, 10 ], 'row-major' ),
zeros( 'generic', [ 10, 10 ], 'row-major' )
];
opts = {
@@ -88,7 +87,6 @@ bench( pkg+'::2d:column-major', function benchmark( b ) {
zeros( 'float64', [ 10, 10 ], 'row-major' ),
zeros( 'float32', [ 10, 10 ], 'row-major' ),
zeros( 'int32', [ 10, 10 ], 'row-major' ),
- zeros( 'complex128', [ 10, 10 ], 'row-major' ),
zeros( 'generic', [ 10, 10 ], 'row-major' )
];
opts = {
@@ -123,7 +121,6 @@ bench( pkg+'::3d:row-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
];
opts = {
@@ -158,7 +155,6 @@ bench( pkg+'::3d:column-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
];
opts = {
@@ -193,7 +189,6 @@ bench( pkg+'::4d:row-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
];
opts = {
@@ -228,7 +223,6 @@ bench( pkg+'::4d:column-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
];
opts = {
@@ -263,7 +257,6 @@ bench( pkg+'::5d:row-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
];
opts = {
@@ -298,7 +291,6 @@ bench( pkg+'::5d:column-major', function benchmark( b ) {
zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
- zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
];
opts = {
From 2ea0120414f72fc16c6ec187999927f8e0feb6ed Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 19:08:10 +0000
Subject: [PATCH 06/22] docs: apply suggestions from code review
---
.../@stdlib/ndarray/flatten-by/README.md | 9 +++++----
.../ndarray/flatten-by/docs/types/index.d.ts | 14 ++++----------
2 files changed, 9 insertions(+), 14 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
index 8212b67a1f45..23b98cf10e2d 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -92,9 +92,10 @@ var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
// returns
var opts = {
- 'depth: 1
+ 'depth': 1
};
-var y = flatten( x, opts, scale );
+
+var y = flattenBy( x, opts, scale );
// returns
var arr = ndarray2array( y );
@@ -115,10 +116,10 @@ var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
// returns
var opts = {
- 'order': 'column-major'
+ 'order': 'column-major'
};
-var y = flatten( x, opts, scale );
+var y = flattenBy( x, opts, scale );
// returns
var arr = ndarray2array( y );
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
index dd01fd443d0e..6cfd06a3a91c 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
@@ -113,7 +113,7 @@ interface Options {
* function scale( value ) {
* return value * 2.0;
* }
-*
+*
* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
* var shape = [ 3, 1, 2 ];
* var strides = [ 2, 2, 1 ];
@@ -146,7 +146,7 @@ declare function flattenBy( x: float64ndarray, fcn: Callback( x: float32ndarray, fcn: Callback( x: complex64ndarray, fcn: Callback( x: genericnda
* function scale( value ) {
* return value * 2.0;
* }
-*
+*
* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
* var shape = [ 3, 1, 2 ];
* var strides = [ 2, 2, 1 ];
@@ -584,7 +578,7 @@ declare function flattenBy( x: float64ndarray, options: Options, fc
* function scale( value ) {
* return value * 2.0;
* }
-*
+*
* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
* var shape = [ 3, 1, 2 ];
* var strides = [ 2, 2, 1 ];
From 08134c46a7b418442713d08b1e902e47cad8e95e Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 19:09:35 +0000
Subject: [PATCH 07/22] docs: apply suggestions from code review
---
.../@stdlib/ndarray/flatten-by/docs/types/index.d.ts | 2 ++
1 file changed, 2 insertions(+)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
index 6cfd06a3a91c..0b5ded998201 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
@@ -20,6 +20,8 @@
///
+/* eslint-disable max-lines */
+
import { float64ndarray, float32ndarray, complex128ndarray, complex64ndarray, int32ndarray, int16ndarray, int8ndarray, uint32ndarray, uint16ndarray, uint8ndarray, uint8cndarray, boolndarray, genericndarray, Order } from '@stdlib/types/ndarray';
import { Complex64, Complex128, ComplexLike } from '@stdlib/types/complex';
From 3af01ed7243ee389adbbe31df5d69a6f8bb6f4a5 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 14 Sep 2025 19:15:58 +0000
Subject: [PATCH 08/22] docs: apply suggestions from code review
---
lib/node_modules/@stdlib/ndarray/flatten-by/README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
index 23b98cf10e2d..cf4ef718840c 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -123,7 +123,7 @@ var y = flattenBy( x, opts, scale );
// returns
var arr = ndarray2array( y );
-// returns [ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+// returns [ 2.0, 6.0, 4.0, 10.0, 8.0, 12.0 ]
```
To set the callback function execution context, provide a `thisArg`.
From 49533b74c97da89a2290e2063b54e497cddaba52 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 15 Sep 2025 00:19:54 +0500
Subject: [PATCH 09/22] docs: apply suggestions from code review
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
lib/node_modules/@stdlib/ndarray/flatten-by/README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
index cf4ef718840c..3b4a2a087e96 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -123,7 +123,7 @@ var y = flattenBy( x, opts, scale );
// returns
var arr = ndarray2array( y );
-// returns [ 2.0, 6.0, 4.0, 10.0, 8.0, 12.0 ]
+// returns [ 2.0, 6.0, 10.0, 4.0, 8.0, 12.0 ]
```
To set the callback function execution context, provide a `thisArg`.
From 959a92d40011b3c8ef11da47dc80cf0c30d451db Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 16 Sep 2025 08:20:26 +0000
Subject: [PATCH 10/22] refactor: apply suggestions from code review
---
.../@stdlib/ndarray/flatten-by/README.md | 4 +-
.../@stdlib/ndarray/flatten-by/docs/repl.txt | 3 +-
.../ndarray/flatten-by/docs/types/index.d.ts | 52 ++++++------
.../@stdlib/ndarray/flatten-by/lib/index.js | 4 +-
.../@stdlib/ndarray/flatten-by/lib/main.js | 82 ++++++++++++++++---
.../@stdlib/ndarray/flatten-by/package.json | 2 +-
6 files changed, 103 insertions(+), 44 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
index 3b4a2a087e96..4c60f9dda8f9 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/README.md
@@ -20,7 +20,7 @@ limitations under the License.
# flattenBy
-> Apply a callback to elements in an input [ndarray][@stdlib/ndarray/ctor] and return a flattened output [ndarray][@stdlib/ndarray/ctor].
+> Flatten an [ndarray][@stdlib/ndarray/ctor] according to a callback function.
@@ -38,7 +38,7 @@ var flattenBy = require( '@stdlib/ndarray/flatten-by' );
#### flattenBy( x\[, options], fcn[, thisArg] )
-Applies a callback to elements in an input [ndarray][@stdlib/ndarray/ctor] and returns a flattened output [ndarray][@stdlib/ndarray/ctor].
+Flattens an [ndarray][@stdlib/ndarray/ctor] according to a callback function.
```javascript
var array = require( '@stdlib/ndarray/array' );
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
index b760777e183a..9db607b8d160 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/repl.txt
@@ -1,7 +1,6 @@
{{alias}}( x[, options], fcn[, thisArg] )
- Applies a callback to elements in an input ndarray and returns a flattened
- output ndarray.
+ Flattens an ndarray according to a callback function.
Parameters
----------
diff --git a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
index 0b5ded998201..0d3f2d937ae6 100644
--- a/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/ndarray/flatten-by/docs/types/index.d.ts
@@ -100,7 +100,7 @@ interface Options {
}
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -133,7 +133,7 @@ interface Options {
declare function flattenBy( x: float64ndarray, fcn: Callback, thisArg?: ThisParameterType> ): float64ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -166,7 +166,7 @@ declare function flattenBy( x: float64ndarray, fcn: Callback( x: float32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): float32ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -196,7 +196,7 @@ declare function flattenBy( x: float32ndarray, fcn: Callback( x: complex64ndarray, fcn: Callback, thisArg?: ThisParameterType> ): complex64ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -226,7 +226,7 @@ declare function flattenBy( x: complex64ndarray, fcn: Callback( x: complex128ndarray, fcn: Callback, thisArg?: ThisParameterType> ): complex128ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -259,7 +259,7 @@ declare function flattenBy( x: complex128ndarray, fcn: Callback( x: int32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int32ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -292,7 +292,7 @@ declare function flattenBy( x: int32ndarray, fcn: Callback( x: int16ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int16ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -325,7 +325,7 @@ declare function flattenBy( x: int16ndarray, fcn: Callback( x: int8ndarray, fcn: Callback, thisArg?: ThisParameterType> ): int8ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -358,7 +358,7 @@ declare function flattenBy( x: int8ndarray, fcn: Callback( x: uint32ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint32ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -391,7 +391,7 @@ declare function flattenBy( x: uint32ndarray, fcn: Callback( x: uint16ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint16ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -424,7 +424,7 @@ declare function flattenBy( x: uint16ndarray, fcn: Callback( x: uint8ndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint8ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -457,7 +457,7 @@ declare function flattenBy( x: uint8ndarray, fcn: Callback( x: uint8cndarray, fcn: Callback, thisArg?: ThisParameterType> ): uint8cndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -490,7 +490,7 @@ declare function flattenBy( x: uint8cndarray, fcn: Callback( x: boolndarray, fcn: Callback, thisArg?: ThisParameterType> ): boolndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param fcn - callback function
@@ -522,7 +522,7 @@ declare function flattenBy( x: boolndarray, fcn: Callback( x: genericndarray, fcn: Callback, V, W>, thisArg?: ThisParameterType, V, W>> ): genericndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -562,7 +562,7 @@ declare function flattenBy( x: genericnda
declare function flattenBy( x: float64ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): float64ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -602,7 +602,7 @@ declare function flattenBy( x: float64ndarray, options: Options, fc
declare function flattenBy( x: float32ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): float32ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -639,7 +639,7 @@ declare function flattenBy( x: float32ndarray, options: Options, fc
declare function flattenBy( x: complex64ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): complex64ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -676,7 +676,7 @@ declare function flattenBy( x: complex64ndarray, options: Options,
declare function flattenBy( x: complex128ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): complex128ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -716,7 +716,7 @@ declare function flattenBy( x: complex128ndarray, options: Options,
declare function flattenBy( x: int32ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): int32ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -756,7 +756,7 @@ declare function flattenBy( x: int32ndarray, options: Options, fcn:
declare function flattenBy( x: int16ndarray, options: Options, fcn: Callback, thisArg?: ThisParameterType> ): int16ndarray;
/**
-* Applies a callback to elements in an input ndarray and returns a flattened output ndarray.
+* Flattens an ndarray according to a callback function.
*
* @param x - input ndarray
* @param options - function options
@@ -796,7 +796,7 @@ declare function flattenBy( x: int16ndarray, options: Options, fcn:
declare function flattenBy