diff --git a/lib/node_modules/@stdlib/stats/meanpw/README.md b/lib/node_modules/@stdlib/stats/meanpw/README.md
new file mode 100644
index 000000000000..ba54dfc14459
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/README.md
@@ -0,0 +1,298 @@
+
+
+# meanpw
+
+> Compute the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions using pairwise summation.
+
+
+
+The [arithmetic mean][arithmetic-mean] is defined as
+
+
+
+```math
+\mu = \frac{1}{n} \sum_{i=0}^{n-1} x_i
+```
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var meanpw = require( '@stdlib/stats/meanpw' );
+```
+
+#### meanpw( x\[, options] )
+
+Computes the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions using pairwise summation.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+
+var y = meanpw( x );
+// returns
+
+var v = y.get();
+// returns 1.25
+```
+
+The function has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+- **dtype**: output ndarray [data type][@stdlib/ndarray/dtypes]. Must be a real-valued floating-point or "generic" [data type][@stdlib/ndarray/dtypes].
+- **keepdims**: boolean indicating whether the reduced dimensions should be included in the returned [ndarray][@stdlib/ndarray/ctor] as singleton dimensions. Default: `false`.
+
+By default, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor]. To perform a reduction over specific dimensions, provide a `dims` option.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, -2.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+var v = ndarray2array( x );
+// returns [ [ 1.0, 2.0 ], [ -2.0, 4.0 ] ]
+
+var y = meanpw( x, {
+ 'dims': [ 0 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ -0.5, 3.0 ]
+
+y = meanpw( x, {
+ 'dims': [ 1 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ 1.5, 1.0 ]
+
+y = meanpw( x, {
+ 'dims': [ 0, 1 ]
+});
+// returns
+
+v = y.get();
+// returns 1.25
+```
+
+By default, the function excludes reduced dimensions from the output [ndarray][@stdlib/ndarray/ctor]. To include the reduced dimensions as singleton dimensions, set the `keepdims` option to `true`.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, -2.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+
+var v = ndarray2array( x );
+// returns [ [ 1.0, 2.0 ], [ -2.0, 4.0 ] ]
+
+var y = meanpw( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ -0.5, 3.0 ] ]
+
+y = meanpw( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 1.5 ], [ 1.0 ] ]
+
+y = meanpw( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 1.25 ] ]
+```
+
+By default, the function returns an [ndarray][@stdlib/ndarray/ctor] having a [data type][@stdlib/ndarray/dtypes] determined by the function's output data type [policy][@stdlib/ndarray/output-dtype-policies]. To override the default behavior, set the `dtype` option.
+
+```javascript
+var getDType = require( '@stdlib/ndarray/dtype' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, -2.0, 4.0 ], {
+ 'dtype': 'generic'
+});
+
+var y = meanpw( x, {
+ 'dtype': 'float64'
+});
+// returns
+
+var dt = String( getDType( y ) );
+// returns 'float64'
+```
+
+#### meanpw.assign( x, out\[, options] )
+
+Computes the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions using pairwise summation and assigns results to a provided output [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+
+var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+var y = zeros( [] );
+
+var out = meanpw.assign( x, y );
+// returns
+
+var v = out.get();
+// returns 1.25
+
+var bool = ( out === y );
+// returns true
+```
+
+The method has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or generic [data type][@stdlib/ndarray/dtypes].
+- **out**: output [ndarray][@stdlib/ndarray/ctor].
+- **options**: function options (_optional_).
+
+The method accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Notes
+
+- Setting the `keepdims` option to `true` can be useful when wanting to ensure that the output [ndarray][@stdlib/ndarray/ctor] is [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with ndarrays having the same shape as the input [ndarray][@stdlib/ndarray/ctor].
+- The output data type [policy][@stdlib/ndarray/output-dtype-policies] only applies to the main function and specifies that, by default, the function must return an [ndarray][@stdlib/ndarray/ctor] having a real-valued floating-point or "generic" [data type][@stdlib/ndarray/dtypes]. For the `assign` method, the output [ndarray][@stdlib/ndarray/ctor] is allowed to have any supported output [data type][@stdlib/ndarray/dtypes].
+- In general, pairwise summation is more numerically stable than ordinary recursive summation (i.e., "simple" summation), with slightly worse performance. While not the most numerically stable summation technique (e.g., compensated summation techniques such as the Kahan–Babuška-Neumaier algorithm are generally more numerically stable), pairwise summation strikes a reasonable balance between numerical stability and performance. If either numerical stability or performance is more desirable for your use case, consider alternative summation techniques.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/uniform' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var meanpw = require( '@stdlib/stats/meanpw' );
+
+// Generate an array of random numbers:
+var x = uniform( [ 5, 5 ], 0.0, 20.0 );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = meanpw( x, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+* * *
+
+
+
+## References
+
+- Higham, Nicholas J. 1993. "The Accuracy of Floating Point Summation." _SIAM Journal on Scientific Computing_ 14 (4): 783–99. doi:[10.1137/0914050][@higham:1993a].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/dtypes
+
+[@stdlib/ndarray/output-dtype-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/output-dtype-policies
+
+[@stdlib/ndarray/base/broadcast-shapes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/broadcast-shapes
+
+[arithmetic-mean]: https://en.wikipedia.org/wiki/Arithmetic_mean
+
+[@higham:1993a]: https://doi.org/10.1137/0914050
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..d60d5698c993
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.assign.js
@@ -0,0 +1,111 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var meanpw = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var out;
+ var x;
+
+ x = uniform( len, -50.0, 50.0, options );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ out = new ndarray( options.dtype, zeros( 1, options.dtype ), [], [ 0 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = meanpw.assign( x, out );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':assign:dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.js
new file mode 100644
index 000000000000..b7a62040bb97
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/benchmark/benchmark.js
@@ -0,0 +1,105 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var meanpw = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var x = uniform( len, -50.0, 50.0, options );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = meanpw( x );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/meanpw/docs/repl.txt b/lib/node_modules/@stdlib/stats/meanpw/docs/repl.txt
new file mode 100644
index 000000000000..3886a34865ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/docs/repl.txt
@@ -0,0 +1,78 @@
+
+{{alias}}( x[, options] )
+ Computes the arithmetic mean along one or more ndarray dimensions using
+ pairwise summation.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ options: Object (optional)
+ Function options.
+
+ options.dtype: string (optional)
+ Output array data type. Must be a real-valued floating-point or
+ "generic" data type.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ options.keepdims: boolean (optional)
+ Boolean indicating whether the reduced dimensions should be included in
+ the returned ndarray as singleton dimensions. Default: false.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, -4.0 ] );
+ > var y = {{alias}}( x );
+ > var v = y.get()
+ -1.5
+
+
+{{alias}}.assign( x, out[, options] )
+ Computes the arithmetic mean along one or more ndarray dimensions using
+ pairwise summation and assigns results to a provided output ndarray.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ out: ndarray
+ Output array.
+
+ options: Object (optional)
+ Function options.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, -4.0 ] );
+ > var out = {{alias:@stdlib/ndarray/zeros}}( [] );
+ > var y = {{alias}}.assign( x, out )
+
+ > var bool = ( out === y )
+ true
+ > var v = out.get()
+ -1.5
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/meanpw/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/meanpw/docs/types/index.d.ts
new file mode 100644
index 000000000000..fb6525c94d6c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/docs/types/index.d.ts
@@ -0,0 +1,151 @@
+/*
+* @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 { ArrayLike } from '@stdlib/types/array';
+import { RealFloatingPointAndGenericDataType as DataType, typedndarray } from '@stdlib/types/ndarray';
+
+/**
+* Input array.
+*/
+type InputArray = typedndarray;
+
+/**
+* Output array.
+*/
+type OutputArray = typedndarray;
+
+/**
+* Interface defining "base" options.
+*/
+interface BaseOptions {
+ /**
+ * List of dimensions over which to perform a reduction.
+ */
+ dims?: ArrayLike;
+}
+
+/**
+* Interface defining options.
+*/
+interface Options extends BaseOptions {
+ /**
+ * Output array data type.
+ */
+ dtype?: DataType;
+
+ /**
+ * Boolean indicating whether the reduced dimensions should be included in the returned array as singleton dimensions. Default: `false`.
+ */
+ keepdims?: boolean;
+}
+
+/**
+* Interface for performing a reduction on an ndarray.
+*/
+interface Unary {
+ /**
+ * Computes the arithmetic mean along one or more ndarray dimensions using pairwise summation.
+ *
+ * @param x - input ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ *
+ * var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+ *
+ * var y = meanpw( x );
+ * // returns
+ *
+ * var v = y.get();
+ * // returns 1.25
+ */
+ ( x: InputArray, options?: Options ): OutputArray; // NOTE: we lose type specificity here, but retaining specificity would likely be difficult and/or tedious to completely enumerate, as the output ndarray data type is dependent on how `x` interacts with output data type policy and whether that policy has been overridden by `options.dtype`.
+
+ /**
+ * Computes the arithmetic mean along one or more ndarray dimensions using pairwise summation and assigns results to a provided output ndarray.
+ *
+ * @param x - input ndarray
+ * @param out - output ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ * var zeros = require( '@stdlib/ndarray/zeros' );
+ *
+ * var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+ * var y = zeros( [] );
+ *
+ * var out = meanpw.assign( x, y );
+ * // returns
+ *
+ * var v = out.get();
+ * // returns 1.25
+ *
+ * var bool = ( out === y );
+ * // returns true
+ */
+ assign = OutputArray>( x: InputArray, out: U, options?: BaseOptions ): U;
+}
+
+/**
+* Computes the arithmetic mean along one or more ndarray dimensions using pairwise summation.
+*
+* @param x - input ndarray
+* @param options - function options
+* @returns output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+*
+* var y = meanpw( x );
+* // returns
+*
+* var v = y.get();
+* // returns 1.25
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+* var y = zeros( [] );
+*
+* var out = meanpw.assign( x, y );
+* // returns
+*
+* var v = out.get();
+* // returns 1.25
+*
+* var bool = ( out === y );
+* // returns true
+*/
+declare const meanpw: Unary;
+
+
+// EXPORTS //
+
+export = meanpw;
diff --git a/lib/node_modules/@stdlib/stats/meanpw/docs/types/test.ts b/lib/node_modules/@stdlib/stats/meanpw/docs/types/test.ts
new file mode 100644
index 000000000000..558dfb7a1b0c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/docs/types/test.ts
@@ -0,0 +1,225 @@
+/*
+* @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 space-in-parens */
+
+///
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import meanpw = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw( x ); // $ExpectType OutputArray
+ meanpw( x, {} ); // $ExpectType OutputArray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ meanpw( '5' ); // $ExpectError
+ meanpw( 5 ); // $ExpectError
+ meanpw( true ); // $ExpectError
+ meanpw( false ); // $ExpectError
+ meanpw( null ); // $ExpectError
+ meanpw( void 0 ); // $ExpectError
+ meanpw( {} ); // $ExpectError
+ meanpw( ( x: number ): number => x ); // $ExpectError
+
+ meanpw( '5', {} ); // $ExpectError
+ meanpw( 5, {} ); // $ExpectError
+ meanpw( true, {} ); // $ExpectError
+ meanpw( false, {} ); // $ExpectError
+ meanpw( null, {} ); // $ExpectError
+ meanpw( void 0, {} ); // $ExpectError
+ meanpw( {}, {} ); // $ExpectError
+ meanpw( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw( x, '5' ); // $ExpectError
+ meanpw( x, true ); // $ExpectError
+ meanpw( x, false ); // $ExpectError
+ meanpw( x, null ); // $ExpectError
+ meanpw( x, [] ); // $ExpectError
+ meanpw( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dtype` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw( x, { 'dtype': '5' } ); // $ExpectError
+ meanpw( x, { 'dtype': 5 } ); // $ExpectError
+ meanpw( x, { 'dtype': true } ); // $ExpectError
+ meanpw( x, { 'dtype': false } ); // $ExpectError
+ meanpw( x, { 'dtype': null } ); // $ExpectError
+ meanpw( x, { 'dtype': [] } ); // $ExpectError
+ meanpw( x, { 'dtype': {} } ); // $ExpectError
+ meanpw( x, { 'dtype': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `keepdims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw( x, { 'keepdims': '5' } ); // $ExpectError
+ meanpw( x, { 'keepdims': 5 } ); // $ExpectError
+ meanpw( x, { 'keepdims': null } ); // $ExpectError
+ meanpw( x, { 'keepdims': [] } ); // $ExpectError
+ meanpw( x, { 'keepdims': {} } ); // $ExpectError
+ meanpw( x, { 'keepdims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw( x, { 'dims': '5' } ); // $ExpectError
+ meanpw( x, { 'dims': 5 } ); // $ExpectError
+ meanpw( x, { 'dims': true } ); // $ExpectError
+ meanpw( x, { 'dims': false } ); // $ExpectError
+ meanpw( x, { 'dims': null } ); // $ExpectError
+ meanpw( x, { 'dims': {} } ); // $ExpectError
+ meanpw( x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw(); // $ExpectError
+ meanpw( x, {}, {} ); // $ExpectError
+}
+
+// Attached to the function is an `assign` method which returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign( x, x ); // $ExpectType float64ndarray
+ meanpw.assign( x, x, {} ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign( '5', x ); // $ExpectError
+ meanpw.assign( 5, x ); // $ExpectError
+ meanpw.assign( true, x ); // $ExpectError
+ meanpw.assign( false, x ); // $ExpectError
+ meanpw.assign( null, x ); // $ExpectError
+ meanpw.assign( void 0, x ); // $ExpectError
+ meanpw.assign( {}, x ); // $ExpectError
+ meanpw.assign( ( x: number ): number => x, x ); // $ExpectError
+
+ meanpw.assign( '5', x, {} ); // $ExpectError
+ meanpw.assign( 5, x, {} ); // $ExpectError
+ meanpw.assign( true, x, {} ); // $ExpectError
+ meanpw.assign( false, x, {} ); // $ExpectError
+ meanpw.assign( null, x, {} ); // $ExpectError
+ meanpw.assign( void 0, x, {} ); // $ExpectError
+ meanpw.assign( {}, x, {} ); // $ExpectError
+ meanpw.assign( ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign( x, '5' ); // $ExpectError
+ meanpw.assign( x, 5 ); // $ExpectError
+ meanpw.assign( x, true ); // $ExpectError
+ meanpw.assign( x, false ); // $ExpectError
+ meanpw.assign( x, null ); // $ExpectError
+ meanpw.assign( x, void 0 ); // $ExpectError
+ meanpw.assign( x, ( x: number ): number => x ); // $ExpectError
+
+ meanpw.assign( x, '5', {} ); // $ExpectError
+ meanpw.assign( x, 5, {} ); // $ExpectError
+ meanpw.assign( x, true, {} ); // $ExpectError
+ meanpw.assign( x, false, {} ); // $ExpectError
+ meanpw.assign( x, null, {} ); // $ExpectError
+ meanpw.assign( x, void 0, {} ); // $ExpectError
+ meanpw.assign( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign( x, x, '5' ); // $ExpectError
+ meanpw.assign( x, x, true ); // $ExpectError
+ meanpw.assign( x, x, false ); // $ExpectError
+ meanpw.assign( x, x, null ); // $ExpectError
+ meanpw.assign( x, x, [] ); // $ExpectError
+ meanpw.assign( x, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign( x, x, { 'dims': '5' } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': 5 } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': true } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': false } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': null } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': {} } ); // $ExpectError
+ meanpw.assign( x, x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ meanpw.assign(); // $ExpectError
+ meanpw.assign( x ); // $ExpectError
+ meanpw.assign( x, x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/meanpw/examples/index.js b/lib/node_modules/@stdlib/stats/meanpw/examples/index.js
new file mode 100644
index 000000000000..352961b9b183
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/examples/index.js
@@ -0,0 +1,40 @@
+/**
+* @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 uniform = require( '@stdlib/random/uniform' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var meanpw = require( './../lib' );
+
+// Generate an array of random numbers:
+var x = uniform( [ 5, 5 ], 0.0, 20.0 );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = meanpw( x, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/stats/meanpw/lib/index.js b/lib/node_modules/@stdlib/stats/meanpw/lib/index.js
new file mode 100644
index 000000000000..d4d674ee9d75
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/lib/index.js
@@ -0,0 +1,63 @@
+/**
+* @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';
+
+/**
+* Compute the arithmetic mean along one or more ndarray dimensions using pairwise summation.
+*
+* @module @stdlib/stats/meanpw
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var meanpw = require( '@stdlib/stats/meanpw' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 0.0, 2.0, 3.0, 0.0, 0.0, 6.0, 7.0, 0.0, 0.0, 10.0, 11.0, 0.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = meanpw( x );
+* // returns
+*
+* var v = out.get();
+* // returns 6.5
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "assign": "main.assign" }
diff --git a/lib/node_modules/@stdlib/stats/meanpw/lib/main.js b/lib/node_modules/@stdlib/stats/meanpw/lib/main.js
new file mode 100644
index 000000000000..0743b1300d6d
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/lib/main.js
@@ -0,0 +1,101 @@
+/**
+* @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 dtypes = require( '@stdlib/ndarray/dtypes' );
+var gmeanpw = require( '@stdlib/stats/base/ndarray/meanpw' );
+var dmeanpw = require( '@stdlib/stats/base/ndarray/dmeanpw' );
+var smeanpw = require( '@stdlib/stats/base/ndarray/smeanpw' );
+var factory = require( '@stdlib/ndarray/base/unary-reduce-strided1d-dispatch-factory' );
+
+
+// VARIABLES //
+
+var idtypes = dtypes( 'real_and_generic' );
+var odtypes = dtypes( 'real_floating_point_and_generic' );
+var policies = {
+ 'output': 'real_floating_point_and_generic',
+ 'casting': 'none'
+};
+var table = {
+ 'types': [
+ 'float64', // input
+ 'float32' // input
+ ],
+ 'fcns': [
+ dmeanpw,
+ smeanpw
+ ],
+ 'default': gmeanpw
+};
+
+
+// MAIN //
+
+/**
+* Computes the arithmetic mean along one or more ndarray dimensions using pairwise summation.
+*
+* @name meanpw
+* @type {Function}
+* @param {ndarray} x - input ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {string} [options.dtype] - output ndarray data type
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 0.0, 2.0, 3.0, 0.0, 0.0, 6.0, 7.0, 0.0, 0.0, 10.0, 11.0, 0.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = meanpw( x );
+* // returns
+*
+* var v = out.get();
+* // returns 6.5
+*/
+var meanpw = factory( table, [ idtypes ], odtypes, policies );
+
+
+// EXPORTS //
+
+module.exports = meanpw;
diff --git a/lib/node_modules/@stdlib/stats/meanpw/package.json b/lib/node_modules/@stdlib/stats/meanpw/package.json
new file mode 100644
index 000000000000..703d9bc73952
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@stdlib/stats/meanpw",
+ "version": "0.0.0",
+ "description": "Compute the arithmetic mean along one or more ndarray dimensions using pairwise summation.",
+ "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",
+ "stdmath",
+ "statistics",
+ "stats",
+ "mathematics",
+ "math",
+ "average",
+ "avg",
+ "mean",
+ "arithmetic mean",
+ "central tendency",
+ "extent",
+ "ndarray"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/meanpw/test/test.assign.js b/lib/node_modules/@stdlib/stats/meanpw/test/test.assign.js
new file mode 100644
index 000000000000..d5488e64ac56
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/test/test.assign.js
@@ -0,0 +1,717 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var meanpw = require( './../lib' ).assign;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof meanpw, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( value, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( value, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ meanpw( value, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ meanpw( value, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( x, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( x, value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a third argument which is not an object', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( x, out, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ 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() {
+ meanpw( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [ 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ -10 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (default)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ meanpw( x, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (all dimensions)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ meanpw( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (some dimensions)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ meanpw( x, out, {
+ 'dims': [ 0 ]
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = meanpw( x, out );
+ expected = 1.25;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = meanpw( x, out );
+ expected = 1.25;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.25;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.25;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': []
+ });
+ expected = [ [ 1.0, 2.0 ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': []
+ });
+ expected = [ [ 1.0, -2.0 ], [ 2.0, 4.0 ] ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ -0.5, 3.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ 1.5, 1.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ 1.5, 1.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = meanpw( x, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ -0.5, 3.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/meanpw/test/test.js b/lib/node_modules/@stdlib/stats/meanpw/test/test.js
new file mode 100644
index 000000000000..77182b89ef17
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/test/test.js
@@ -0,0 +1,39 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isMethod = require( '@stdlib/assert/is-method' );
+var meanpw = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof meanpw, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is an `assign` method', function test( t ) {
+ t.strictEqual( isMethod( meanpw, 'assign' ), true, 'returns expected value' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/meanpw/test/test.main.js b/lib/node_modules/@stdlib/stats/meanpw/test/test.main.js
new file mode 100644
index 000000000000..4ad825b1aa46
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/meanpw/test/test.main.js
@@ -0,0 +1,753 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var meanpw = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof meanpw, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like 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() {
+ meanpw( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (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() {
+ meanpw( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ meanpw( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ meanpw( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ meanpw( x, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dtype` option which is not a supported data type', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+ 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() {
+ meanpw( x, {
+ 'dtype': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `keepdims` option which is not a boolean', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ 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() {
+ meanpw( x, {
+ 'keepdims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ 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() {
+ meanpw( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ -10 ],
+ [ 0, 20 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ meanpw( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x );
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x );
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.25 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.25 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [],
+ 'keepdims': false
+ });
+ expected = [ [ 1.0, 2.0 ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0, 2.0 ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [],
+ 'keepdims': false
+ });
+ expected = [ [ 1.0, -2.0 ], [ 2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0, -2.0 ], [ 2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0 ],
+ 'keepdims': false
+ });
+ expected = [ -0.5, 3.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ -0.5, 3.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 1 ],
+ 'keepdims': false
+ });
+ expected = [ 1.5, 1.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.5 ], [ 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0 ],
+ 'keepdims': false
+ });
+ expected = [ 1.5, 1.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.5, 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 1 ],
+ 'keepdims': false
+ });
+ expected = [ -0.5, 3.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ -0.5 ], [ 3.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the output array data type', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = meanpw( x, {
+ 'dtype': 'float64'
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, 2.0, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = meanpw( x, {
+ 'dtype': 'float64'
+ });
+ expected = 1.25;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/mskmax/README.md b/lib/node_modules/@stdlib/stats/mskmax/README.md
new file mode 100644
index 000000000000..bb4b8dfc148c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/README.md
@@ -0,0 +1,295 @@
+
+
+# mskmax
+
+> Compute the maximum value along one or more [ndarray][@stdlib/ndarray/ctor] dimensions according to a mask.
+
+
+
+## Usage
+
+```javascript
+var mskmax = require( '@stdlib/stats/mskmax' );
+```
+
+#### mskmax( x, mask\[, options] )
+
+Compute the maximum value along one or more [ndarray][@stdlib/ndarray/ctor] dimensions according to a mask.
+
+```javascript
+var Uint8Array = require( '@stdlib/array/uint8' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0 ] );
+var mask = array( new Uint8Array( [ 0, 0, 1 ] ) );
+
+var y = mskmax( x, mask );
+// returns
+
+var v = y.get();
+// returns 2.0
+```
+
+The function has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **mask**: mask [ndarray][@stdlib/ndarray/ctor]. Must be [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with `x`. If a mask element is `0`, the corresponding element in `x` is considered valid. If a mask element is non-zero, the corresponding element in `x` is ignored.
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+- **dtype**: output ndarray [data type][@stdlib/ndarray/dtypes]. Must be a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **keepdims**: boolean indicating whether the reduced dimensions should be included in the returned [ndarray][@stdlib/ndarray/ctor] as singleton dimensions. Default: `false`.
+
+By default, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor]. To perform a reduction over specific dimensions, provide a `dims` option.
+
+```javascript
+var Uint8Array = require( '@stdlib/array/uint8' );
+var mskmax = require( '@stdlib/stats/mskmax' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ), {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+var v = ndarray2array( x );
+// returns [ [ -1.0, 2.0 ], [ -3.0, 4.0 ] ]
+
+var y = mskmax( x, mask, {
+ 'dims': [ 0 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ -1.0, 4.0 ]
+
+y = mskmax( x, mask, {
+ 'dims': [ 1 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ 2.0, 4.0 ]
+
+y = mskmax( x, mask, {
+ 'dims': [ 0, 1 ]
+});
+// returns
+
+v = y.get();
+// returns 4.0
+```
+
+By default, the function excludes reduced dimensions from the output [ndarray][@stdlib/ndarray/ctor]. To include the reduced dimensions as singleton dimensions, set the `keepdims` option to `true`.
+
+```javascript
+var Uint8Array = require( '@stdlib/array/uint8' );
+var mskmax = require( '@stdlib/stats/mskmax' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ), {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+
+var v = ndarray2array( x );
+// returns [ [ -1.0, 2.0 ], [ -3.0, 4.0 ] ]
+
+var y = mskmax( x, mask, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ -1.0, 4.0 ] ]
+
+y = mskmax( x, mask, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 2.0 ], [ 4.0 ] ]
+
+y = mskmax( x, mask, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 4.0 ] ]
+```
+
+By default, the function returns an [ndarray][@stdlib/ndarray/ctor] having a [data type][@stdlib/ndarray/dtypes] determined by the function's output data type [policy][@stdlib/ndarray/output-dtype-policies]. To override the default behavior, set the `dtype` option.
+
+```javascript
+var Uint8Array = require( '@stdlib/array/uint8' );
+var mskmax = require( '@stdlib/stats/mskmax' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0 ], {
+ 'dtype': 'generic'
+});
+var mask = array( new Uint8Array( [ 0, 0, 1 ] ) );
+
+var y = mskmax( x, mask, {
+ 'dtype': 'float64'
+});
+// returns
+
+var dt = String( getDType( y ) );
+// returns 'float64'
+```
+
+#### mskmax.assign( x, mask, out\[, options] )
+
+Computes the maximum value of [ndarray][@stdlib/ndarray/ctor] along one or more dimensions and assigns results to a provided output [ndarray][@stdlib/ndarray/ctor] according to mask.
+
+```javascript
+var Uint8Array = require( '@stdlib/array/uint8' );
+var mskmax = require( '@stdlib/stats/mskmax' );
+var array = require( '@stdlib/ndarray/array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+
+var x = array( [ -1.0, 2.0, -3.0 ] );
+var mask = array( new Uint8Array( [ 0, 0, 1 ] ) );
+var y = zeros( [] );
+
+var out = mskmax.assign( x, mask, y );
+// returns
+
+var v = out.get();
+// returns 2.0
+
+var bool = ( out === y );
+// returns true
+```
+
+The method has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or generic [data type][@stdlib/ndarray/dtypes].
+- **mask**: mask [ndarray][@stdlib/ndarray/ctor]. Must be [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with `x`. If a mask element is `0`, the corresponding element in `x` is considered valid. If a mask element is non-zero, the corresponding element in `x` is ignored.
+- **out**: output [ndarray][@stdlib/ndarray/ctor].
+- **options**: function options (_optional_).
+
+The method accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Notes
+
+- Setting the `keepdims` option to `true` can be useful when wanting to ensure that the output [ndarray][@stdlib/ndarray/ctor] is [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with ndarrays having the same shape as the input [ndarray][@stdlib/ndarray/ctor].
+- The output data type [policy][@stdlib/ndarray/output-dtype-policies] only applies to the main function and specifies that, by default, the function must return an [ndarray][@stdlib/ndarray/ctor] having the same [data type][@stdlib/ndarray/dtypes] as the input [ndarray][@stdlib/ndarray/ctor]. For the `assign` method, the output [ndarray][@stdlib/ndarray/ctor] is allowed to have any supported output [data type][@stdlib/ndarray/dtypes].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var mskmax = require( '@stdlib/stats/mskmax' );
+
+// Generate an array of random numbers:
+var xbuf = discreteUniform( 25, 0, 20, {
+ 'dtype': 'generic'
+});
+
+// Generate a mask array:
+var mbuf = discreteUniform( 25, 0, 1, {
+ 'dtype': 'uint8'
+});
+
+// Wrap in ndarrays:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+var mask = new ndarray( 'uint8', mbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+console.log( ndarray2array( mask ) );
+
+// Perform a reduction:
+var y = mskmax( x, mask, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/dtypes
+
+[@stdlib/ndarray/output-dtype-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/output-dtype-policies
+
+[@stdlib/ndarray/base/broadcast-shapes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/broadcast-shapes
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..674f055d30d6
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.assign.js
@@ -0,0 +1,121 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var mskmax = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var mask;
+ var mbuf;
+ var out;
+ var x;
+ var i;
+
+ x = uniform( len, -50.0, 50.0, options );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ // Create a mask (mask out every 5th element):
+ mbuf = [];
+ for ( i = 0; i < len; i++ ) {
+ mbuf.push( ( i % 5 === 0 ) ? 1 : 0 );
+ }
+ mask = new ndarray( 'uint8', mbuf, [ len ], [ 1 ], 0, 'row-major' );
+
+ out = new ndarray( options.dtype, zeros( 1, options.dtype ), [], [ 0 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = mskmax.assign( x, mask, out );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':assign:dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.js
new file mode 100644
index 000000000000..7b99e9b1c45e
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/benchmark/benchmark.js
@@ -0,0 +1,117 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var mskmax = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var mask;
+ var mbuf;
+ var x;
+ var i;
+
+ x = uniform( len, -50.0, 50.0, options );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ // Create a mask (mask out every 5th element):
+ mbuf = [];
+ for ( i = 0; i < len; i++ ) {
+ mbuf.push( ( i % 5 === 0 ) ? 1 : 0 );
+ }
+ mask = new ndarray( 'uint8', mbuf, [ len ], [ 1 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = mskmax( x, mask );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/mskmax/docs/repl.txt b/lib/node_modules/@stdlib/stats/mskmax/docs/repl.txt
new file mode 100644
index 000000000000..3683db427347
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/docs/repl.txt
@@ -0,0 +1,91 @@
+
+{{alias}}( x, mask[, options] )
+ Computes the maximum value along one or more ndarray dimensions
+ according to a mask.
+
+ If a `mask` array element is `0`, the corresponding element in `x` is
+ considered valid and included in computation.
+
+ If a `mask` array element is `1`, the corresponding element in `x` is
+ considered invalid/missing and excluded from computation.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ mask: ndarray
+ Mask array. Must have an integer data type and the same shape as `x`.
+
+ options: Object (optional)
+ Function options.
+
+ options.dtype: string (optional)
+ Output array data type. Must be a real-valued or "generic" data type.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ options.keepdims: boolean (optional)
+ Boolean indicating whether the reduced dimensions should be included in
+ the returned ndarray as singleton dimensions. Default: false.
+
+ Returns
+ -------
+ y: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, 4.0 ] );
+ > var mask = {{alias:@stdlib/ndarray/array}}( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+ > var y = {{alias}}( x, mask );
+ > var v = y.get()
+ 4.0
+
+
+{{alias}}.assign( x, mask, out[, options] )
+ Computes the maximum value along one or more ndarray dimensions and assigns
+ results to a provided output ndarray according to a mask.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or generic data type.
+
+ mask: ndarray
+ Mask array. Must have an integer data type and the same shape as `x`.
+
+ out: ndarray
+ Output array.
+
+ options: Object (optional)
+ Function options.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, 4.0 ] );
+ > var mask = {{alias:@stdlib/ndarray/array}}( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+ > var out = {{alias:@stdlib/ndarray/zeros}}( [] );
+ > var y = {{alias}}.assign( x, mask, out )
+
+ > var bool = ( out === y )
+ true
+ > var v = out.get()
+ 4.0
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/mskmax/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/mskmax/docs/types/index.d.ts
new file mode 100644
index 000000000000..4373d4390377
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/docs/types/index.d.ts
@@ -0,0 +1,158 @@
+/*
+* @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 { ArrayLike } from '@stdlib/types/array';
+import { RealAndGenericDataType as DataType, typedndarray } from '@stdlib/types/ndarray';
+
+/**
+* Input array.
+*/
+type InputArray = typedndarray;
+
+/**
+* Output array.
+*/
+type OutputArray = typedndarray;
+
+/**
+* Interface defining "base" options.
+*/
+interface BaseOptions {
+ /**
+ * List of dimensions over which to perform a reduction.
+ */
+ dims?: ArrayLike;
+}
+
+/**
+* Interface defining options.
+*/
+interface Options extends BaseOptions {
+ /**
+ * Output array data type.
+ */
+ dtype?: DataType;
+
+ /**
+ * Boolean indicating whether the reduced dimensions should be included in the returned array as singleton dimensions. Default: `false`.
+ */
+ keepdims?: boolean;
+}
+
+/**
+* Interface for performing a reduction on an ndarray.
+*/
+interface Unary {
+ /**
+ * Computes the maximum value along one or more ndarray dimensions according to a mask.
+ *
+ * @param x - input ndarray
+ * @param mask - mask ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ *
+ * var x = array( [ -1.0, 2.0, -3.0, 4.0 ] );
+ * var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+ *
+ * var y = mskmax( x, mask );
+ * // returns
+ *
+ * var v = y.get();
+ * // returns 4.0
+ */
+ ( x: InputArray, mask: InputArray, options?: Options ): OutputArray; // NOTE: we lose type specificity here, but retaining specificity would likely be difficult and/or tedious to completely enumerate, as the output ndarray data type is dependent on how `x` interacts with output data type policy and whether that policy has been overridden by `options.dtype`.
+
+ /**
+ * Computes the maximum value along one or more ndarray dimensions and assigns results to a provided output ndarray according to a mask.
+ *
+ * @param x - input ndarray
+ * @param mask - mask ndarray
+ * @param out - output ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ * var zeros = require( '@stdlib/ndarray/zeros' );
+ *
+ * var x = array( [ -1.0, 2.0, -3.0, 4.0 ] );
+ * var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+ * var y = zeros( [] );
+ *
+ * var out = mskmax.assign( x, mask, y );
+ * // returns
+ *
+ * var v = out.get();
+ * // returns 4.0
+ *
+ * var bool = ( out === y );
+ * // returns true
+ */
+ assign = OutputArray>( x: InputArray, mask: InputArray, out: U, options?: BaseOptions ): U;
+}
+
+/**
+* Computes the maximum value along one or more ndarray dimensions according to a mask.
+*
+* @param x - input ndarray
+* @param mask - mask ndarray
+* @param options - function options
+* @returns output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+* var x = array( [ -1.0, 2.0, -3.0, 4.0 ] )
+* var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+*
+* var y = mskmax( x, mask );
+* // returns
+*
+* var v = y.get();
+* // returns 4.0
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* var x = array( [ -1.0, 2.0, -3.0, 4.0 ] )
+* var mask = array( new Uint8Array( [ 0, 0, 1, 0 ] ) );
+* var y = zeros( [] );
+*
+* var out = mskmax.assign( x, mask, y );
+* // returns
+*
+* var v = out.get();
+* // returns 4.0
+*
+* var bool = ( out === y );
+* // returns true
+*/
+declare const mskmax: Unary;
+
+
+// EXPORTS //
+
+export = mskmax;
diff --git a/lib/node_modules/@stdlib/stats/mskmax/docs/types/test.ts b/lib/node_modules/@stdlib/stats/mskmax/docs/types/test.ts
new file mode 100644
index 000000000000..24a831499f9c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/docs/types/test.ts
@@ -0,0 +1,225 @@
+/*
+* @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 space-in-parens */
+
+///
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import mskmax = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax( x ); // $ExpectType OutputArray
+ mskmax( x, {} ); // $ExpectType OutputArray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ mskmax( '5' ); // $ExpectError
+ mskmax( 5 ); // $ExpectError
+ mskmax( true ); // $ExpectError
+ mskmax( false ); // $ExpectError
+ mskmax( null ); // $ExpectError
+ mskmax( void 0 ); // $ExpectError
+ mskmax( {} ); // $ExpectError
+ mskmax( ( x: number ): number => x ); // $ExpectError
+
+ mskmax( '5', {} ); // $ExpectError
+ mskmax( 5, {} ); // $ExpectError
+ mskmax( true, {} ); // $ExpectError
+ mskmax( false, {} ); // $ExpectError
+ mskmax( null, {} ); // $ExpectError
+ mskmax( void 0, {} ); // $ExpectError
+ mskmax( {}, {} ); // $ExpectError
+ mskmax( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax( x, '5' ); // $ExpectError
+ mskmax( x, true ); // $ExpectError
+ mskmax( x, false ); // $ExpectError
+ mskmax( x, null ); // $ExpectError
+ mskmax( x, [] ); // $ExpectError
+ mskmax( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dtype` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax( x, { 'dtype': '5' } ); // $ExpectError
+ mskmax( x, { 'dtype': 5 } ); // $ExpectError
+ mskmax( x, { 'dtype': true } ); // $ExpectError
+ mskmax( x, { 'dtype': false } ); // $ExpectError
+ mskmax( x, { 'dtype': null } ); // $ExpectError
+ mskmax( x, { 'dtype': [] } ); // $ExpectError
+ mskmax( x, { 'dtype': {} } ); // $ExpectError
+ mskmax( x, { 'dtype': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `keepdims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax( x, { 'keepdims': '5' } ); // $ExpectError
+ mskmax( x, { 'keepdims': 5 } ); // $ExpectError
+ mskmax( x, { 'keepdims': null } ); // $ExpectError
+ mskmax( x, { 'keepdims': [] } ); // $ExpectError
+ mskmax( x, { 'keepdims': {} } ); // $ExpectError
+ mskmax( x, { 'keepdims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax( x, { 'dims': '5' } ); // $ExpectError
+ mskmax( x, { 'dims': 5 } ); // $ExpectError
+ mskmax( x, { 'dims': true } ); // $ExpectError
+ mskmax( x, { 'dims': false } ); // $ExpectError
+ mskmax( x, { 'dims': null } ); // $ExpectError
+ mskmax( x, { 'dims': {} } ); // $ExpectError
+ mskmax( x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax(); // $ExpectError
+ mskmax( x, {}, {} ); // $ExpectError
+}
+
+// Attached to the function is an `assign` method which returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign( x, x ); // $ExpectType float64ndarray
+ mskmax.assign( x, x, {} ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign( '5', x ); // $ExpectError
+ mskmax.assign( 5, x ); // $ExpectError
+ mskmax.assign( true, x ); // $ExpectError
+ mskmax.assign( false, x ); // $ExpectError
+ mskmax.assign( null, x ); // $ExpectError
+ mskmax.assign( void 0, x ); // $ExpectError
+ mskmax.assign( {}, x ); // $ExpectError
+ mskmax.assign( ( x: number ): number => x, x ); // $ExpectError
+
+ mskmax.assign( '5', x, {} ); // $ExpectError
+ mskmax.assign( 5, x, {} ); // $ExpectError
+ mskmax.assign( true, x, {} ); // $ExpectError
+ mskmax.assign( false, x, {} ); // $ExpectError
+ mskmax.assign( null, x, {} ); // $ExpectError
+ mskmax.assign( void 0, x, {} ); // $ExpectError
+ mskmax.assign( {}, x, {} ); // $ExpectError
+ mskmax.assign( ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign( x, '5' ); // $ExpectError
+ mskmax.assign( x, 5 ); // $ExpectError
+ mskmax.assign( x, true ); // $ExpectError
+ mskmax.assign( x, false ); // $ExpectError
+ mskmax.assign( x, null ); // $ExpectError
+ mskmax.assign( x, void 0 ); // $ExpectError
+ mskmax.assign( x, ( x: number ): number => x ); // $ExpectError
+
+ mskmax.assign( x, '5', {} ); // $ExpectError
+ mskmax.assign( x, 5, {} ); // $ExpectError
+ mskmax.assign( x, true, {} ); // $ExpectError
+ mskmax.assign( x, false, {} ); // $ExpectError
+ mskmax.assign( x, null, {} ); // $ExpectError
+ mskmax.assign( x, void 0, {} ); // $ExpectError
+ mskmax.assign( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign( x, x, '5' ); // $ExpectError
+ mskmax.assign( x, x, true ); // $ExpectError
+ mskmax.assign( x, x, false ); // $ExpectError
+ mskmax.assign( x, x, null ); // $ExpectError
+ mskmax.assign( x, x, [] ); // $ExpectError
+ mskmax.assign( x, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign( x, x, { 'dims': '5' } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': 5 } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': true } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': false } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': null } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': {} } ); // $ExpectError
+ mskmax.assign( x, x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ mskmax.assign(); // $ExpectError
+ mskmax.assign( x ); // $ExpectError
+ mskmax.assign( x, x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/mskmax/examples/index.js b/lib/node_modules/@stdlib/stats/mskmax/examples/index.js
new file mode 100644
index 000000000000..d459cb992d70
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/examples/index.js
@@ -0,0 +1,55 @@
+/**
+* @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 getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var mskmax = require( './../lib' );
+
+// Generate an array of random numbers:
+var xbuf = discreteUniform( 25, 0, 20, {
+ 'dtype': 'generic'
+});
+
+// Wrap in an ndarray:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+// Generate a mask (mask out random elements):
+var mbuf = discreteUniform( 25, 0, 1, {
+ 'dtype': 'uint8'
+});
+
+// Wrap mask in an ndarray:
+var mask = new ndarray( 'uint8', mbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( mask ) );
+
+// Perform a reduction:
+var y = mskmax( x, mask, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/stats/mskmax/lib/base.js b/lib/node_modules/@stdlib/stats/mskmax/lib/base.js
new file mode 100644
index 000000000000..e329a2e82a01
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/lib/base.js
@@ -0,0 +1,80 @@
+/**
+* @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 dtypes = require( '@stdlib/ndarray/dtypes' );
+var gmskmax = require( '@stdlib/stats/base/ndarray/mskmax' );
+var dmskmax = require( '@stdlib/stats/base/ndarray/dmskmax' );
+var smskmax = require( '@stdlib/stats/base/ndarray/smskmax' );
+var factory = require( '@stdlib/ndarray/base/binary-reduce-strided1d-dispatch-factory' );
+
+
+// VARIABLES //
+
+var idtypes = dtypes( 'real_and_generic' );
+var mdtypes = dtypes( 'mask_index_and_generic' );
+var odtypes = dtypes( 'real_and_generic' );
+var policies = {
+ 'output': 'promoted',
+ 'casting': 'none'
+};
+var table = {
+ 'types': [
+ 'float64',
+ 'uint8', // dmskmax: x, mask
+ 'float32',
+ 'uint8' // smskmax: x, mask
+ ],
+ 'fcns': [
+ dmskmax,
+ smskmax
+ ],
+ 'default': gmskmax
+};
+
+
+// MAIN //
+
+/**
+* Base implementation for computing the maximum value along one or more ndarray dimensions according to a mask.
+*
+* @name base
+* @type {Function}
+* @param {ndarray} x - input ndarray
+* @param {ndarray} mask - mask ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {string} [options.dtype] - output ndarray data type
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} second argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*/
+var base = factory( table, [ idtypes, mdtypes ], odtypes, policies );
+
+
+// EXPORTS //
+
+module.exports = base;
diff --git a/lib/node_modules/@stdlib/stats/mskmax/lib/index.js b/lib/node_modules/@stdlib/stats/mskmax/lib/index.js
new file mode 100644
index 000000000000..c04de4252ffd
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/lib/index.js
@@ -0,0 +1,70 @@
+/**
+* @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';
+
+/**
+* Compute the maximum value along one or more ndarray dimensions according to a mask.
+*
+* @module @stdlib/stats/mskmax
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var Uint8Array = require( '@stdlib/array/uint8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var mskmax = require( '@stdlib/stats/mskmax' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 0.0, 2.0, 3.0, 0.0, 0.0, 6.0, 7.0, 0.0, 0.0, 10.0, 11.0, 0.0 ] );
+*
+* // Create a mask buffer:
+* var mbuf = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ] ); // eslint-disable-line id-length
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Create a mask ndarray:
+* var mask = new ndarray( 'uint8', mbuf, sh, sx, ox, 'row-major' ); // cspell:disable-line
+*
+* // Perform reduction:
+* var out = mskmax( x, mask );
+* // returns
+*
+* var v = out.get();
+* // returns 10.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "assign": "main.assign" }
diff --git a/lib/node_modules/@stdlib/stats/mskmax/lib/main.js b/lib/node_modules/@stdlib/stats/mskmax/lib/main.js
new file mode 100644
index 000000000000..4def17733364
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/lib/main.js
@@ -0,0 +1,183 @@
+/**
+* @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 isNdarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var format = require( '@stdlib/string/format' );
+var maybeBroadcastArrays = require( '@stdlib/ndarray/base/maybe-broadcast-arrays' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Computes the maximum value along one or more ndarray dimensions according to a mask.
+*
+* @param {ndarray} x - input ndarray
+* @param {ndarray} mask - mask ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {string} [options.dtype] - output ndarray data type
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} second argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var Uint8Array = require( '@stdlib/array/uint8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+*
+* // Create a mask buffer:
+* var mbuf = new Uint8Array( [ 0, 0, 0, 1, 0, 1 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sm = [ 2, 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+* var om = 0;
+*
+* // Create the input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Create the mask ndarray:
+* var mask = new ndarray( 'uint8', mbuf, sh, sm, om, 'row-major' ); // cspell:disable-line
+*
+* // Perform reduction:
+* var out = mskmax( x, mask );
+* // returns
+*
+* var v = out.get();
+* // returns 5.0
+*/
+function mskmax( x, mask ) {
+ var arrs;
+ if ( !isNdarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ if ( !isNdarrayLike( mask ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an ndarray-like object. Value: `%s`.', mask ) );
+ }
+ arrs = maybeBroadcastArrays( [ x, mask ] );
+ if ( arguments.length > 2 ) {
+ return base( arrs[ 0 ], arrs[ 1 ], arguments[ 2 ] );
+ }
+ return base( arrs[ 0 ], arrs[ 1 ] );
+}
+
+/**
+* Computes the maximum value along one or more ndarray dimensions according to a mask and assigns the results to a provided output ndarray.
+*
+* @name assign
+* @memberof mskmax
+* @type {Function}
+* @param {ndarray} x - input ndarray
+* @param {ndarray} mask - mask ndarray
+* @param {ndarray} out - output ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} second argument must be an ndarray-like object
+* @throws {TypeError} third argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var Uint8Array = require( '@stdlib/array/uint8' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+*
+* // Create a mask buffer:
+* var mbuf = new Uint8Array( [ 0, 0, 0, 1, 0, 1 ] );
+*
+* // Create an output buffer:
+* var obuf = new Float64Array( [ 0.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sm = [ 2, 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+* var om = 0;
+*
+* // Create the input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Create the mask ndarray:
+* var mask = new ndarray( 'uint8', mbuf, sh, sm, om, 'row-major' ); // cspell:disable-line
+*
+* // Create the output ndarray:
+* var out = new ndarray( 'float64', obuf, [], [ 0 ], 0, 'row-major' );
+*
+* // Perform reduction:
+* var res = mskmax.assign( x, mask, out );
+* // returns
+*
+* var v = res.get();
+* // returns 5.0
+*/
+function assign( x, mask, out ) {
+ var arrs;
+ if ( !isNdarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ if ( !isNdarrayLike( mask ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an ndarray-like object. Value: `%s`.', mask ) );
+ }
+ if ( !isNdarrayLike( out ) ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray-like object. Value: `%s`.', out ) );
+ }
+ arrs = maybeBroadcastArrays( [ x, mask ] );
+ if ( arguments.length > 3 ) {
+ return base.assign( arrs[ 0 ], arrs[ 1 ], out, arguments[ 3 ] );
+ }
+ return base.assign( arrs[ 0 ], arrs[ 1 ], out );
+}
+
+mskmax.assign = assign;
+
+
+// EXPORTS //
+
+module.exports = mskmax;
diff --git a/lib/node_modules/@stdlib/stats/mskmax/package.json b/lib/node_modules/@stdlib/stats/mskmax/package.json
new file mode 100644
index 000000000000..a1890c8ee07a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@stdlib/stats/mskmax",
+ "version": "0.0.0",
+ "description": "Compute the maximum value along one or more ndarray dimensions according to a mask.",
+ "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",
+ "stdmath",
+ "statistics",
+ "stats",
+ "mathematics",
+ "math",
+ "maximum",
+ "max",
+ "range",
+ "extremes",
+ "domain",
+ "extent",
+ "ndarray"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/mskmax/test/test.assign.js b/lib/node_modules/@stdlib/stats/mskmax/test/test.assign.js
new file mode 100644
index 000000000000..56042b75ce73
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/test/test.assign.js
@@ -0,0 +1,819 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var mskmax = require( './../lib' ).assign;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof mskmax, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var i;
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ mskmax( value, mask, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var i;
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ mskmax( value, mask, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var i;
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ mskmax( value, mask, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var i;
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ mskmax( value, mask, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ 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() {
+ mskmax( x, mask, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ 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() {
+ mskmax( x, mask, value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a third argument which is not an object', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ mskmax( x, mask, out, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ 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() {
+ mskmax( x, mask, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [ 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ -10 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, mask, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, mask, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var mask;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, mask, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (default)', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ mskmax( x, mask, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (all dimensions)', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ mskmax( x, mask, out, {
+ 'dims': [ 0, 1 ]
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (some dimensions)', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ values = [
+ [],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ mskmax( x, mask, out, {
+ 'dims': [ 0 ]
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = mskmax( x, mask, out );
+ expected = 2.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = mskmax( x, mask, out );
+ expected = 2.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 2.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 2.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': []
+ });
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], 2.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], -3.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': []
+ });
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], -3.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], 2.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ -1.0, 2.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ 2.0, -3.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ 2.0, -3.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = mskmax( x, mask, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ -1.0, 2.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/mskmax/test/test.js b/lib/node_modules/@stdlib/stats/mskmax/test/test.js
new file mode 100644
index 000000000000..e53eacc98f42
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/test/test.js
@@ -0,0 +1,39 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isMethod = require( '@stdlib/assert/is-method' );
+var mskmax = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof mskmax, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is an `assign` method', function test( t ) {
+ t.strictEqual( isMethod( mskmax, 'assign' ), true, 'returns expected value' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/mskmax/test/test.main.js b/lib/node_modules/@stdlib/stats/mskmax/test/test.main.js
new file mode 100644
index 000000000000..5256254d6be4
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/mskmax/test/test.main.js
@@ -0,0 +1,873 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var mskmax = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof mskmax, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like 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() {
+ mskmax( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (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() {
+ mskmax( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ mskmax( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ 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() {
+ mskmax( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ 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() {
+ mskmax( x, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dtype` option which is not a supported data type', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+ 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() {
+ mskmax( x, {
+ 'dtype': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `keepdims` option which is not a boolean', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ 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() {
+ mskmax( x, {
+ 'keepdims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ 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() {
+ mskmax( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ values = [
+ [ -10 ],
+ [ 0, 20 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, mask, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var mask;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ mask = zeros( [ 2, 2 ], {
+ 'dtype': 'uint8'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, mask, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ mskmax( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask );
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask );
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 2.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 2.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var actual;
+ var xbuf;
+ var mbuf;
+ var mask;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': false
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], 2.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], -3.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': true
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], 2.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], -3.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var actual;
+ var xbuf;
+ var mbuf;
+ var mask;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': false
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], -3.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], 2.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': true
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], -3.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], 2.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var mbuf;
+ var mask;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': false
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], 2.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], -3.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ -1.0, 2.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 1 ],
+ 'keepdims': false
+ });
+ expected = [ 2.0, -3.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': true
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], 2.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], -3.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var mbuf;
+ var mask;
+ var arr;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0 ],
+ 'keepdims': false
+ });
+ expected = [ 2.0, -3.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ 2.0, -3.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': false
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], -3.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], 2.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dims': [],
+ 'keepdims': true
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ arr = ndarray2array( actual );
+ t.strictEqual( arr[0][0], -1.0, 'returns expected value' );
+ t.strictEqual( arr[0][1], -3.0, 'returns expected value' );
+ t.strictEqual( arr[1][0], 2.0, 'returns expected value' );
+ t.ok( arr[1][1] !== arr[1][1], 'returns NaN for masked value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the output array data type', function test( t ) {
+ var expected;
+ var actual;
+ var mbuf;
+ var mask;
+ var xbuf;
+ var x;
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = mskmax( x, mask, {
+ 'dtype': 'float64'
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ mbuf = [ 0, 0, 0, 1 ];
+ mask = new ndarray( 'uint8', mbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = mskmax( x, mask, {
+ 'dtype': 'float64'
+ });
+ expected = 2.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});