diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/README.md b/lib/node_modules/@stdlib/stats/incr/nanmmda/README.md
new file mode 100644
index 000000000000..a7a60097576b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/README.md
@@ -0,0 +1,173 @@
+
+
+# incrnanmmda
+
+> Compute a moving [mean directional accuracy][mean-directional-accuracy] (MDA) incrementally, ignoring `NaN` values.
+
+
+
+For a window of size `W`, the [mean directional accuracy][mean-directional-accuracy] is defined as
+
+
+
+```math
+\mathop{\mathrm{MDA}} = \begin{cases} 1 & \textrm{if}\ W = 1 \\ \frac{1}{W} \sum_{i=1}^{W} \delta_{\mathop{\mathrm{sgn}}(\Delta f_{i,i-1}),\ \mathop{\mathrm{sgn}}(\Delta a_{i,i-1})} & \textrm{if}\ W > 1 \end{cases}
+```
+
+
+
+
+
+where `f_i` is the forecast value, `a_i` is the actual value, `sgn(x)` is the [signum][@stdlib/math/base/special/signum] function, and `δ` is the [Kronecker delta][@stdlib/math/base/special/kronecker-delta].
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var incrnanmmda = require( '@stdlib/stats/incr/nanmmda' );
+```
+
+#### incrnanmmda( window )
+
+Returns an accumulator `function` which incrementally computes a moving [mean directional accuracy][mean-directional-accuracy], ignoring `NaN` values. The `window` parameter defines the number of values over which to compute the moving [mean directional accuracy][mean-directional-accuracy].
+
+```javascript
+var accumulator = incrnanmmda( 3 );
+```
+
+#### accumulator( \[f, a] )
+
+If provided input values `f` and `a`, the accumulator function returns an updated [mean directional accuracy][mean-directional-accuracy]. If not provided input values `f` and `a`, the accumulator function returns the current [mean directional accuracy][mean-directional-accuracy].
+
+```javascript
+var accumulator = incrnanmmda( 3 );
+
+var m = accumulator();
+// returns null
+
+m = accumulator( NaN, 4.0 );
+// returns null
+
+// Fill the window...
+m = accumulator( 2.0, 3.0 ); // [(+,+)]
+// returns 1.0
+
+m = accumulator( 1.0, 4.0 ); // [(+,+), (-,+)]
+// returns 0.5
+
+m = accumulator( 3.0, NaN ); // [(+,+), (-,+)]
+// returns 0.5
+
+m = accumulator( 3.0, 9.0 ); // [(+,+), (-,+), (+,+)]
+// returns ~0.67
+
+// Window begins sliding...
+m = accumulator( 7.0, 3.0 ); // [(-,+), (+,+), (+,-)]
+// returns ~0.33
+
+m = accumulator( NaN, NaN ); // [(-,+), (+,+), (+,-)]
+// returns -0.33
+
+m = accumulator( 5.0, 3.0 ); // [(+,+), (+,-), (-,0)]
+// returns ~0.33
+
+m = accumulator();
+// returns ~0.33
+```
+
+
+
+
+
+
+
+## Notes
+
+- Input values are **not** type checked. If provided `NaN` or a value which, when used in computations, results in `NaN`, the accumulated value is **not** changed and the current input values get **ignored**. If non-numeric inputs are possible, you are advised to type check and handle accordingly **before** passing the value to the accumulator function.
+- As `W` (f,a) pairs are needed to fill the window buffer, the first `W-1` returned values are calculated from smaller sample sizes. Until the window is full, each returned value is calculated from all provided values.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var randu = require( '@stdlib/random/base/randu' );
+var incrnanmmda = require( '@stdlib/stats/incr/nanmmda' );
+
+var accumulator;
+var v1;
+var v2;
+var i;
+
+// Initialize an accumulator:
+accumulator = incrnanmmda( 5 );
+
+// For each simulated datum, update the moving mean directional accuracy...
+for ( i = 0; i < 100; i++ ) {
+ v1 = ( bernoulli( 0.1 ) ) ? NaN : ( randu()*100.0 ) - 50.0;
+ v2 = ( bernoulli( 0.1 ) ) ? NaN : ( randu()*100.0 ) - 50.0;
+ accumulator( v1, v2 );
+}
+console.log( accumulator() );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[mean-directional-accuracy]: https://en.wikipedia.org/wiki/Mean_Directional_Accuracy_%28MDA%29
+
+[@stdlib/math/base/special/signum]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/signum
+
+[@stdlib/math/base/special/kronecker-delta]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/kronecker-delta
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/incr/nanmmda/benchmark/benchmark.js
new file mode 100644
index 000000000000..fc41818e7716
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/benchmark/benchmark.js
@@ -0,0 +1,69 @@
+/**
+* @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 randu = require( '@stdlib/random/base/randu' );
+var pkg = require( './../package.json' ).name;
+var incrnanmmda = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var f;
+ var i;
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ f = incrnanmmda( ( i%5 ) + 1 );
+ if ( typeof f !== 'function' ) {
+ b.fail( 'should return a function' );
+ }
+ }
+ b.toc();
+ if ( typeof f !== 'function' ) {
+ b.fail( 'should return a function' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::accumulator', function benchmark( b ) {
+ var acc;
+ var v;
+ var i;
+
+ acc = incrnanmmda( 5 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = acc( randu()-0.5, randu()-0.5 );
+ if ( v !== v ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( v !== v ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/img/equation_mean_directional_accuracy.svg b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/img/equation_mean_directional_accuracy.svg
new file mode 100644
index 000000000000..266057954f27
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/img/equation_mean_directional_accuracy.svg
@@ -0,0 +1,115 @@
+
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/repl.txt b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/repl.txt
new file mode 100644
index 000000000000..1639f016da83
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/repl.txt
@@ -0,0 +1,50 @@
+
+{{alias}}( W )
+ Returns an accumulator function which incrementally computes a moving
+ mean directional accuracy (MDA), ignoring `NaN` values.
+
+ The `W` parameter defines the number of values over which to compute the
+ moving mean directional accuracy.
+
+ If provided input values, the accumulator function returns an updated moving
+ mean directional accuracy. If not provided input values or if either of the
+ provided values is `NaN`, the accumulator function returns the current
+ moving mean directional accuracy.
+
+ As `W` (f,a) pairs are needed to fill the window buffer, the first `W-1`
+ returned values are calculated from smaller sample sizes. Until the window
+ is full, each returned value is calculated from all provided values.
+
+ Parameters
+ ----------
+ W: integer
+ Window size.
+
+ Returns
+ -------
+ acc: Function
+ Accumulator function.
+
+ Examples
+ --------
+ > var accumulator = {{alias}}( 3 );
+ > var m = accumulator()
+ null
+ > m = accumulator( 2.0, 3.0 )
+ 1.0
+ > m = accumulator( 5.0, 2.0 )
+ 0.5
+ > m = accumulator( NaN, NaN )
+ 0.5
+ > m = accumulator( 3.0, 2.0 )
+ ~0.33
+ > m = accumulator( 4.0, NaN )
+ ~0.33
+ > m = accumulator( 4.0, 5.0 )
+ ~0.33
+ > m = accumulator()
+ ~0.33
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/index.d.ts
new file mode 100644
index 000000000000..68f915220995
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/index.d.ts
@@ -0,0 +1,83 @@
+/*
+* @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
+
+///
+
+/**
+* If provided a value, the accumulator function returns an updated mean directional accuracy. If not provided a value or if either of the provided values is `NaN`, the accumulator function returns the current mean directional accuracy.
+*
+* ## Notes
+*
+* - If provided `NaN` or a value which, when used in computations, results in `NaN`, the accumulated value is not updated and the current value is returned.
+*
+* @param f - forecast value
+* @param a - actual value
+* @returns mean directional accuracy or null
+*/
+type accumulator = ( f?: number, a?: number ) => number | null;
+
+/**
+* Returns an accumulator function which incrementally computes a moving mean directional accuracy, ignoring `NaN` values.
+*
+* ## Notes
+*
+* - The `W` parameter defines the number of values over which to compute the moving mean directional accuracy.
+* - As `W` (f,a) pairs are needed to fill the window buffer, the first `W-1` returned values are calculated from smaller sample sizes. Until the window is full, each returned value is calculated from all provided values.
+*
+* @param W - window size
+* @throws must provide a positive integer
+* @returns accumulator function
+*
+* @example
+* var accumulator = incrnanmmda( 3 );
+*
+* var m = accumulator();
+* // returns null
+*
+* m = accumulator( NaN, 4.0 );
+* // returns null
+*
+* m = accumulator( 2.0, 3.0 );
+* // returns 1.0
+*
+* m = accumulator( 5.0, 2.0 );
+* // returns 0.5
+*
+* m = accumulator( NaN, NaN );
+* // returns 0.5
+*
+* m = accumulator( 3.0, 2.0 );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, NaN );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, 5.0 );
+* // returns ~0.33
+*
+* m = accumulator();
+* // returns ~0.33
+*/
+declare function incrnanmmda( W: number ): accumulator;
+
+
+// EXPORTS //
+
+export = incrnanmmda;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/test.ts b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/test.ts
new file mode 100644
index 000000000000..11ee6f2de0d8
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/docs/types/test.ts
@@ -0,0 +1,75 @@
+/*
+* @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.
+*/
+
+import incrnanmmda = require( './index' );
+
+
+// TESTS //
+
+// The function returns an accumulator function...
+{
+ incrnanmmda( 3 ); // $ExpectType accumulator
+}
+
+// The compiler throws an error if the function is provided an argument that is not a number...
+{
+ incrnanmmda( '5' ); // $ExpectError
+ incrnanmmda( true ); // $ExpectError
+ incrnanmmda( false ); // $ExpectError
+ incrnanmmda( null ); // $ExpectError
+ incrnanmmda( undefined ); // $ExpectError
+ incrnanmmda( [] ); // $ExpectError
+ incrnanmmda( {} ); // $ExpectError
+ incrnanmmda( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid number of arguments...
+{
+ incrnanmmda(); // $ExpectError
+ incrnanmmda( 3, 2 ); // $ExpectError
+}
+
+// The function returns an accumulator function which returns an accumulated result...
+{
+ const acc = incrnanmmda( 3 );
+
+ acc(); // $ExpectType number | null
+ acc( NaN, 2.0 ); // $ExpectType number | null
+ acc( 3.14, 2.0 ); // $ExpectType number | null
+}
+
+// The compiler throws an error if the returned accumulator function is provided invalid arguments...
+{
+ const acc = incrnanmmda( 3 );
+
+ acc( '5', 2.0 ); // $ExpectError
+ acc( true, 2.0 ); // $ExpectError
+ acc( false, 2.0 ); // $ExpectError
+ acc( null, 2.0 ); // $ExpectError
+ acc( [], 2.0 ); // $ExpectError
+ acc( {}, 2.0 ); // $ExpectError
+ acc( ( x: number ): number => x, 2.0 ); // $ExpectError
+
+ acc( 3.14, '5' ); // $ExpectError
+ acc( 3.14, true ); // $ExpectError
+ acc( 3.14, false ); // $ExpectError
+ acc( 3.14, null ); // $ExpectError
+ acc( 3.14, [] ); // $ExpectError
+ acc( 3.14, {} ); // $ExpectError
+ acc( 3.14, ( x: number ): number => x ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/examples/index.js b/lib/node_modules/@stdlib/stats/incr/nanmmda/examples/index.js
new file mode 100644
index 000000000000..fbcb9e9fdd2f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/examples/index.js
@@ -0,0 +1,45 @@
+/**
+* @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 bernoulli = require( '@stdlib/random/base/bernoulli' );
+var randu = require( '@stdlib/random/base/randu' );
+var incrnanmmda = require( './../lib' );
+
+var accumulator;
+var v1;
+var v2;
+var m;
+var i;
+
+// Initialize an accumulator:
+accumulator = incrnanmmda( 5 );
+
+// For each simulated datum, update the moving mean directional accuracy...
+console.log( '\nValue\tValue\tMDA\n' );
+for ( i = 0; i < 100; i++ ) {
+ v1 = ( bernoulli( 0.1 ) ) ? NaN : ( randu()*100.0 ) - 50.0;
+ v2 = ( bernoulli( 0.1 ) ) ? NaN : ( randu()*100.0 ) - 50.0;
+ m = accumulator( v1, v2 );
+ if ( m === null ) {
+ console.log( '%d\t%d\t%s', v1.toFixed( 3 ), v2.toFixed( 3 ), m );
+ } else {
+ console.log( '%d\t%d\t%d', v1.toFixed( 3 ), v2.toFixed( 3 ), m.toFixed( 3 ) );
+ }
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/index.js b/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/index.js
new file mode 100644
index 000000000000..b3e1fc5cac18
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/index.js
@@ -0,0 +1,66 @@
+/**
+* @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 a moving mean directional accuracy incrementally, ignoring `NaN` values.
+*
+* @module @stdlib/stats/incr/nanmmda
+*
+* @example
+* var incrnanmmda = require( '@stdlib/stats/incr/nanmmda' );
+*
+* var accumulator = incrnanmmda( 3 );
+*
+* var m = accumulator();
+* // returns null
+*
+* m = accumulator( NaN, 4.0 );
+* // returns null
+*
+* m = accumulator( 2.0, 3.0 );
+* // returns 1.0
+*
+* m = accumulator( 5.0, 2.0 );
+* // returns 0.5
+*
+* m = accumulator( NaN, NaN );
+* // returns 0.5
+*
+* m = accumulator( 3.0, 2.0 );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, NaN );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, 5.0 );
+* // returns ~0.33
+*
+* m = accumulator();
+* // returns ~0.33
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/main.js b/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/main.js
new file mode 100644
index 000000000000..e8e4991d9f13
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/lib/main.js
@@ -0,0 +1,86 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var incrmmda = require( '@stdlib/stats/incr/mmda' );
+
+
+// MAIN //
+
+/**
+* Returns an accumulator function which incrementally computes a moving mean directional accuracy, ignoring `NaN` values.
+*
+* @param {PositiveInteger} W - window size
+* @throws {TypeError} must provide a positive integer
+* @returns {Function} accumulator function
+*
+* @example
+* var accumulator = incrnanmmda( 3 );
+*
+* var m = accumulator();
+* // returns null
+*
+* m = accumulator( 2.0, 3.0 );
+* // returns 1.0
+*
+* m = accumulator( 5.0, 2.0 );
+* // returns 0.5
+*
+* m = accumulator( NaN, NaN );
+* // returns 0.5
+*
+* m = accumulator( 3.0, 2.0 );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, NaN );
+* // returns ~0.33
+*
+* m = accumulator( 4.0, 5.0 );
+* // returns ~0.33
+*
+* m = accumulator();
+* // returns ~0.33
+*/
+function incrnanmmda( W ) {
+ var mmda = incrmmda( W );
+ return accumulator;
+
+ /**
+ * If provided input values, the accumulator function returns an updated mean directional accuracy. If not provided input values or if either of the values provided is NaN, the accumulator function returns the current mean directional.
+ *
+ * @private
+ * @param {number} [f] - forecast value
+ * @param {number} [a] - actual value
+ * @returns {(number|null)} mean directional accuracy or null
+ */
+ function accumulator( f, a ) {
+ if ( arguments.length === 0 || isnan( f ) || isnan( a ) ) {
+ return mmda();
+ }
+ return mmda( f, a );
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = incrnanmmda;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/package.json b/lib/node_modules/@stdlib/stats/incr/nanmmda/package.json
new file mode 100644
index 000000000000..cf4ea7537fa8
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/package.json
@@ -0,0 +1,82 @@
+{
+ "name": "@stdlib/stats/incr/nanmmda",
+ "version": "0.0.0",
+ "description": "Compute a moving mean directional accuracy (MDA) incrementally, ignoring `NaN` values.",
+ "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",
+ "direction",
+ "directional",
+ "accuracy",
+ "trend",
+ "incremental",
+ "accumulator",
+ "moving mean",
+ "moving average",
+ "sliding window",
+ "sliding",
+ "window",
+ "moving",
+ "time series",
+ "timeseries",
+ "demand",
+ "forecasting",
+ "forecast",
+ "economics",
+ "econ",
+ "finance"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmda/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmmda/test/test.js
new file mode 100644
index 000000000000..79b97d93a537
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmda/test/test.js
@@ -0,0 +1,152 @@
+/**
+* @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 abs = require( '@stdlib/math/base/special/abs' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var incrnanmmda = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof incrnanmmda, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a positive integer', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ -5.0,
+ 0.0,
+ 3.14,
+ true,
+ null,
+ void 0,
+ NaN,
+ [],
+ {},
+ 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() {
+ incrnanmmda( value );
+ };
+ }
+});
+
+tape( 'the function returns an accumulator function', function test( t ) {
+ t.equal( typeof incrnanmmda( 3 ), 'function', 'returns a function' );
+ t.end();
+});
+
+tape( 'the accumulator function computes a moving mean directional accuracy incrementally', function test( t ) {
+ var expected;
+ var actual;
+ var delta;
+ var data;
+ var acc;
+ var tol;
+ var N;
+ var i;
+
+ data = [
+ [ 2.0, 3.0 ], // +,+
+ [ 3.0, 1.0 ], // +,-
+ [ 5.0, 2.0 ], // +,+
+ [ NaN, 2.0 ], // 0,0
+ [ 4.0, 4.0 ], // -,+
+ [ -3.0, 10.0 ], // -,+
+ [ 3.0, NaN ], // 0,0
+ [ 4.0, -5.0 ], // +,-
+ [ NaN, NaN ], // 0,0
+ [ 4.0, -5.0 ], // 0,0
+ [ -4.0, -6.0 ] // -,-
+ ];
+ N = data.length;
+
+ acc = incrnanmmda( 3 );
+
+ // Note: manually computed
+ expected = [
+ 1.0,
+ 1.0/2.0,
+ 2.0/3.0,
+ 2.0/3.0,
+ 1.0/3.0,
+ 1.0/3.0,
+ 1.0/3.0,
+ 0.0/3.0,
+ 0.0/3.0,
+ 1.0/3.0,
+ 2.0/3.0
+ ];
+ for ( i = 0; i < N; i++ ) {
+ actual = acc( data[i][0], data[i][1] );
+ if ( actual === expected[i] ) {
+ t.equal( actual, expected[i], 'returns expected value' );
+ } else {
+ delta = abs( expected[i] - actual );
+ tol = 1.0 * EPS * abs( expected[i] );
+ t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'if not provided an input value, the accumulator function returns the current mean directional accuracy', function test( t ) {
+ var data;
+ var acc;
+ var i;
+
+ data = [
+ [ NaN, NaN ], // 0,0
+ [ 2.0, 3.0 ], // +,+
+ [ 3.0, 5.0 ], // +,+
+ [ NaN, 2.0 ], // 0,0
+ [ 1.0, 10.0 ] // -,+
+ ];
+ acc = incrnanmmda( 2 );
+ for ( i = 0; i < data.length; i++ ) {
+ acc( data[i][0], data[i][1] );
+ }
+ t.equal( acc(), 0.5, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
+ var acc = incrnanmmda( 3 );
+ t.equal( acc(), null, 'returns null' );
+ acc( NaN, 1.0 );
+ t.equal( acc(), null, 'returns null' );
+ t.end();
+});