diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/README.md b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/README.md
new file mode 100644
index 000000000000..b097f182e712
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/README.md
@@ -0,0 +1,235 @@
+
+
+# incrnanmmeanstdev
+
+> Compute a moving [arithmetic mean][arithmetic-mean] and [corrected sample standard deviation][standard-deviation] incrementally, ignoring `NaN` values.
+
+
+
+For a window of size `W`, the [arithmetic mean][arithmetic-mean] is defined as
+
+
+
+```math
+\bar{x} = \frac{1}{W} \sum_{i=0}^{W-1} x_i
+```
+
+
+
+
+
+and the [corrected sample standard deviation][standard-deviation] is defined as
+
+
+
+```math
+s = \sqrt{\frac{1}{W-1} \sum_{i=0}^{W-1} ( x_i - \bar{x} )^2}
+```
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var incrnanmmeanstdev = require( '@stdlib/stats/incr/nanmmeanstdev' );
+```
+
+#### incrnanmmeanstdev( \[out,] window )
+
+Returns an accumulator function which incrementally computes a moving [arithmetic mean][arithmetic-mean] and [corrected sample standard deviation][standard-deviation], ignoring `NaN` values. The `window` parameter defines the number of values over which to compute the moving [arithmetic mean][arithmetic-mean] and [corrected sample standard deviation][standard-deviation].
+
+```javascript
+var accumulator = incrnanmmeanstdev( 3 );
+```
+
+By default, the returned accumulator `function` returns the accumulated values as a two-element `array`. To avoid unnecessary memory allocation, the function supports providing an output (destination) object.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var accumulator = incrnanmmeanstdev( new Float64Array( 2 ), 3 );
+```
+
+#### accumulator( \[x] )
+
+If provided an input value `x`, the accumulator function returns updated accumulated values. If not provided an input value `x`, the accumulator function returns the current accumulated values.
+
+```javascript
+var accumulator = incrnanmmeanstdev( 3 );
+
+var out = accumulator();
+// returns null
+
+// Fill the window...
+out = accumulator( 2.0 ); // [2.0]
+// returns [ 2.0, 0.0 ]
+
+out = accumulator( 1.0 ); // [2.0, 1.0]
+// returns [ 1.5, ~0.71 ]
+
+out = accumulator( 3.0 ); // [2.0, 1.0, 3.0]
+// returns [ 2.0, 1.0 ]
+
+out = accumulator( NaN ); // [2.0, 1.0, 3.0]
+// returns [ 2.0, 1.0 ]
+
+// Window begins sliding...
+out = accumulator( -7.0 ); // [1.0, 3.0, -7.0]
+// returns [ -1.0, ~5.29 ]
+
+out = accumulator( -5.0 ); // [3.0, -7.0, -5.0]
+// returns [ -3.0, ~5.29 ]
+
+out = accumulator();
+// returns [ -3.0, ~5.29 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- Input values are **not** type checked. 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` values 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 randu = require( '@stdlib/random/base/randu' );
+var Float64Array = require( '@stdlib/array/float64' );
+var ArrayBuffer = require( '@stdlib/array/buffer' );
+var incrnanmmeanstdev = require( '@stdlib/stats/incr/nanmmeanstdev' );
+
+var offset;
+var acc;
+var buf;
+var out;
+var ms;
+var N;
+var v;
+var i;
+var j;
+
+// Define the number of accumulators:
+N = 5;
+
+// Create an array buffer for storing accumulator output:
+buf = new ArrayBuffer( N*2*8 ); // 8 bytes per element
+
+// Initialize accumulators:
+acc = [];
+for ( i = 0; i < N; i++ ) {
+ // Compute the byte offset:
+ offset = i * 2 * 8; // stride=2, bytes_per_element=8
+
+ // Create a new view for storing accumulated values:
+ out = new Float64Array( buf, offset, 2 );
+
+ // Initialize an accumulator which will write results to the view:
+ acc.push( incrnanmmeanstdev( out, 5 ) );
+}
+
+// Simulate data and update the moving sample means and standard deviations...
+for ( i = 0; i < 100; i++ ) {
+ for ( j = 0; j < N; j++ ) {
+ v = randu() * 100.0 * (j+1);
+ acc[ j ]( v );
+ }
+}
+
+// Print the final results:
+console.log( 'Mean\tStDev' );
+for ( i = 0; i < N; i++ ) {
+ ms = acc[ i ]();
+ console.log( '%d\t%d', ms[ 0 ].toFixed( 3 ), ms[ 1 ].toFixed( 3 ) );
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[arithmetic-mean]: https://en.wikipedia.org/wiki/Arithmetic_mean
+
+[standard-deviation]: https://en.wikipedia.org/wiki/Standard_deviation
+
+
+
+[@stdlib/stats/incr/meanstdev]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/incr/meanstdev
+
+[@stdlib/stats/incr/mmean]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/incr/mmean
+
+[@stdlib/stats/incr/mmeanvar]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/incr/mmeanvar
+
+[@stdlib/stats/incr/mstdev]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/incr/mstdev
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/benchmark/benchmark.js
new file mode 100644
index 000000000000..c219c78d3fdd
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/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( '@stdlib/stats/incr/nanmmeanstdev/package.json' ).name;
+var incrnanmmeanstdev = require( '@stdlib/stats/incr/nanmmeanstdev/lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var f;
+ var i;
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ f = incrnanmmeanstdev( (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 = incrnanmmeanstdev( 5 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = acc( randu() );
+ if ( v.length !== 2 ) {
+ b.fail( 'should contain two elements' );
+ }
+ }
+ b.toc();
+ if ( v[ 0 ] !== v[ 0 ] || v[ 1 ] !== v[ 1 ] ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_arithmetic_mean.svg b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_arithmetic_mean.svg
new file mode 100644
index 000000000000..1a89a2bfb996
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_arithmetic_mean.svg
@@ -0,0 +1,43 @@
+
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_corrected_sample_standard_deviation.svg b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_corrected_sample_standard_deviation.svg
new file mode 100644
index 000000000000..dfe5a3d60cbb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/img/equation_corrected_sample_standard_deviation.svg
@@ -0,0 +1,73 @@
+
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/index.d.ts
new file mode 100644
index 000000000000..023e7ac8c2eb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/index.d.ts
@@ -0,0 +1,94 @@
+/*
+* @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';
+
+/**
+* If provided a value, the accumulator function returns an updated moving arithmetic mean and corrected sample standard deviation. If provided NaN or no value, the accumulator function returns the current moving arithmetic mean and corrected sample standard deviation.
+*
+* @param x - input value
+* @returns output array or null
+*/
+type accumulator = ( x?: number ) => ArrayLike | null;
+
+/**
+* Returns an accumulator function which incrementally computes a moving arithmetic mean and corrected sample standard deviation, ignoring NaN values.
+*
+* ## Notes
+*
+* - The `W` parameter defines the number of values over which to compute the moving arithmetic mean and corrected sample standard deviation.
+* - As `W` values are needed to fill the window buffer, the first `W-1` returned moving arithmetic mean and corrected sample standard deviation are calculated from smaller sample sizes. Until the window is full, each returned moving arithmetic mean and corrected sample standard deviation is calculated from all provided values.
+*
+* @param out - output array
+* @param window - window size
+* @throws window size must be a positive integer
+* @returns accumulator function
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var accumulator = incrmnanmeanstdev( new Float64Array( 2 ), 3 );
+*
+* var mm = accumulator();
+* // returns null
+*/
+declare function incrmnanmeanstdev( out: ArrayLike, window: number ): accumulator;
+
+/**
+* Returns an accumulator function which incrementally computes a moving arithmetic mean and corrected sample standard deviation, ignoring NaN values.
+*
+* ## Notes
+*
+* - The `W` parameter defines the number of values over which to compute the moving arithmetic mean and corrected sample standard deviation.
+* - As `W` values are needed to fill the window buffer, the first `W-1` returned moving arithmetic mean and corrected sample standard deviation are calculated from smaller sample sizes. Until the window is full, each returned moving arithmetic mean and corrected sample standard deviation is calculated from all provided values.
+*
+* @param window - window size
+* @throws window size must be a positive integer
+* @returns accumulator function
+*
+* @example
+* var accumulator = incrnanmmeanstdev( 3 );
+*
+* var v = accumulator();
+* // returns null
+*
+* v = accumulator( 2.0 );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( NaN );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( -5.0 );
+* // returns [ -1.5, ~4.95 ]
+*
+* v = accumulator( 3.0 );
+* // returns [ 0.0, ~4.36 ]
+*
+* v = accumulator();
+* // returns [ 0.0, ~4.36 ]
+*/
+declare function incrmnanmeanstdev( window: number ): accumulator;
+
+
+// EXPORTS //
+
+export = incrmnanmeanstdev;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/test.ts b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/test.ts
new file mode 100644
index 000000000000..84b9d2daa60c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/docs/types/test.ts
@@ -0,0 +1,78 @@
+/*
+* @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 incrnanmmeanstdev = require( '@stdlib/stats/incr/nanmmeanstdev' );
+
+
+// TESTS //
+
+// The function returns an accumulator function...
+{
+ incrnanmmeanstdev( 3 ); // $ExpectType accumulator
+ const out = [ 0.0, 0.0 ];
+ incrnanmmeanstdev( out, 3 ); // $ExpectType accumulator
+}
+
+// The compiler throws an error if the function is provided a last argument that is not a number...
+{
+ incrnanmmeanstdev( '5' ); // $ExpectError
+ incrnanmmeanstdev( true ); // $ExpectError
+ incrnanmmeanstdev( false ); // $ExpectError
+ incrnanmmeanstdev( null ); // $ExpectError
+ incrnanmmeanstdev( {} ); // $ExpectError
+ incrnanmmeanstdev( ( x: number ): number => x ); // $ExpectError
+
+ const out = [ 0.0, 0.0 ];
+ incrnanmmeanstdev( out, '5' ); // $ExpectError
+ incrnanmmeanstdev( out, true ); // $ExpectError
+ incrnanmmeanstdev( out, false ); // $ExpectError
+ incrnanmmeanstdev( out, null ); // $ExpectError
+ incrnanmmeanstdev( out, {} ); // $ExpectError
+ incrnanmmeanstdev( out, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an output array that is not an array-like object of numbers...
+{
+ incrnanmmeanstdev( '5', 3 ); // $ExpectError
+ incrnanmmeanstdev( true, 3 ); // $ExpectError
+ incrnanmmeanstdev( false, 3 ); // $ExpectError
+ incrnanmmeanstdev( null, 3 ); // $ExpectError
+ incrnanmmeanstdev( {}, 3 ); // $ExpectError
+ incrnanmmeanstdev( ( x: number ): number => x, 3 ); // $ExpectError
+}
+
+// The function returns an accumulator function which returns an accumulated result...
+{
+ const acc = incrnanmmeanstdev( 3 );
+
+ acc(); // $ExpectType ArrayLike | null
+ acc( 3.14 ); // $ExpectType ArrayLike | null
+}
+
+// The compiler throws an error if the returned accumulator function is provided invalid arguments...
+{
+ const acc = incrnanmmeanstdev( 3 );
+
+ acc( '5' ); // $ExpectError
+ acc( true ); // $ExpectError
+ acc( false ); // $ExpectError
+ acc( null ); // $ExpectError
+ acc( [] ); // $ExpectError
+ acc( {} ); // $ExpectError
+ acc( ( x: number ): number => x ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/examples/index.js b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/examples/index.js
new file mode 100644
index 000000000000..b23e15a034cb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/examples/index.js
@@ -0,0 +1,68 @@
+/**
+* @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 randu = require( '@stdlib/random/base/randu' );
+var Float64Array = require( '@stdlib/array/float64' );
+var ArrayBuffer = require( '@stdlib/array/buffer' );
+var incrnanmmeanstdev = require( './../lib' );
+
+var offset;
+var acc;
+var buf;
+var out;
+var ms;
+var N;
+var v;
+var i;
+var j;
+
+// Define the number of accumulators:
+N = 5;
+
+// Create an array buffer for storing accumulator output:
+buf = new ArrayBuffer( N*2*8 ); // 8 bytes per element
+
+// Initialize accumulators:
+acc = [];
+for ( i = 0; i < N; i++ ) {
+ // Compute the byte offset:
+ offset = i * 2 * 8; // stride=2, bytes_per_element=8
+
+ // Create a new view for storing accumulated values:
+ out = new Float64Array( buf, offset, 2 );
+
+ // Initialize an accumulator which will write results to the view:
+ acc.push( incrnanmmeanstdev( out, 5 ) );
+}
+
+// Simulate data and update the moving sample means and standard deviations...
+for ( i = 0; i < 100; i++ ) {
+ for ( j = 0; j < N; j++ ) {
+ v = randu() * 100.0 * (j+1);
+ acc[ j ]( v );
+ }
+}
+
+// Print the final results:
+console.log( 'Mean\tStDev' );
+for ( i = 0; i < N; i++ ) {
+ ms = acc[ i ]();
+ console.log( '%d\t%d', ms[ 0 ].toFixed( 3 ), ms[ 1 ].toFixed( 3 ) );
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/index.js b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/index.js
new file mode 100644
index 000000000000..0006f78ebae6
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/index.js
@@ -0,0 +1,57 @@
+/**
+* @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 arithmetic mean and corrected sample standard deviation incrementally, ignoring `NaN` values.
+*
+* @module @stdlib/stats/incr/nanmmeanstdev
+*
+* @example
+* var incrnanmmeanstdev = require( '@stdlib/stats/incr/nanmmeanstdev' );
+*
+* var accumulator = incrnanmmeanstdev( 3 );
+*
+* var v = accumulator();
+* // returns null
+*
+* v = accumulator( 2.0 );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( NaN );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( -5.0 );
+* // returns [ -1.5, ~4.95 ]
+*
+* v = accumulator( 3.0 );
+* // returns [ 0.0, ~4.36 ]
+*
+* v = accumulator();
+* // returns [ 0.0, ~4.36 ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/main.js b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/main.js
new file mode 100644
index 000000000000..93e919fb5bcf
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/lib/main.js
@@ -0,0 +1,156 @@
+/**
+* @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 incrmmeanstdev = require( '@stdlib/stats/incr/mmeanstdev' );
+
+
+// MAIN //
+
+/**
+* Returns an accumulator function which incrementally computes a moving arithmetic mean and corrected sample standard deviation, ignoring `NaN` values.
+*
+* ## Method
+*
+* - Let \\(W\\) be a window of \\(N\\) elements over which we want to compute a corrected sample standard deviation.
+*
+* - We first recognize that the corrected sample standard deviation is defined as the square root of the unbiased sample variance. Accordingly, in order to derive an update equation for the corrected sample standard deviation, deriving an update equation for the unbiased sample variance is sufficient.
+*
+* - The difference between the unbiased sample variance in a window \\(W_i\\) and the unbiased sample variance in a window \\(W_{i+1})\\) is given by
+*
+* ```tex
+* \Delta s^2 = s_{i+1}^2 - s_{i}^2
+* ```
+*
+* - If we multiply both sides by \\(N-1\\),
+*
+* ```tex
+* (N-1)(\Delta s^2) = (N-1)s_{i+1}^2 - (N-1)s_{i}^2
+* ```
+*
+* - If we substitute the definition of the unbiased sample variance having the form
+*
+* ```tex
+* \begin{align*}
+* s^2 &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} (x_i - \bar{x})^2 \biggr) \\
+* &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} (x_i^2 - 2\bar{x}x_i + \bar{x}^2) \biggr) \\
+* &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} x_i^2 - 2\bar{x} \sum_{i=1}^{N} x_i + \sum_{i=1}^{N} \bar{x}^2) \biggr) \\
+* &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} x_i^2 - \frac{2N\bar{x}\sum_{i=1}^{N} x_i}{N} + N\bar{x}^2 \biggr) \\
+* &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} x_i^2 - 2N\bar{x}^2 + N\bar{x}^2 \biggr) \\
+* &= \frac{1}{N-1} \biggl( \sum_{i=1}^{N} x_i^2 - N\bar{x}^2 \biggr)
+* \end{align*}
+* ```
+*
+* we return
+*
+* ```tex
+* (N-1)(\Delta s^2) = \biggl(\sum_{k=1}^N x_k^2 - N\bar{x}_{i+1}^2 \biggr) - \biggl(\sum_{k=0}^{N-1} x_k^2 - N\bar{x}_{i}^2 \biggr)
+* ```
+*
+* - This can be further simplified by recognizing that subtracting the sums reduces to \\(x_N^2 - x_0^2\\); in which case,
+*
+* ```tex
+* \begin{align*}
+* (N-1)(\Delta s^2) &= x_N^2 - x_0^2 - N\bar{x}_{i+1}^2 + N\bar{x}_{i}^2 \\
+* &= x_N^2 - x_0^2 - N(\bar{x}_{i+1}^2 - \bar{x}_{i}^2) \\
+* &= x_N^2 - x_0^2 - N(\bar{x}_{i+1} - \bar{x}_{i})(\bar{x}_{i+1} + \bar{x}_{i})
+* \end{align*}
+* ```
+*
+* - Recognizing that the difference of means can be expressed
+*
+* ```tex
+* \bar{x}_{i+1} - \bar{x}_i = \frac{1}{N} \biggl( \sum_{k=1}^N x_k - \sum_{k=0}^{N-1} x_k \biggr) = \frac{x_N - x_0}{N}
+* ```
+*
+* and substituting into the equation above
+*
+* ```tex
+* (N-1)(\Delta s^2) = x_N^2 - x_0^2 - (x_N - x_0)(\bar{x}_{i+1} + \bar{x}_{i})
+* ```
+*
+* - Rearranging terms gives us the update equation
+*
+* ```tex
+* \begin{align*}
+* (N-1)(\Delta s^2) &= (x_N - x_0)(x_N + x_0) - (x_N - x_0)(\bar{x}_{i+1} + \bar{x}_{i})
+* &= (x_N - x_0)(x_N + x_0 - \bar{x}_{i+1} - \bar{x}_{i}) \\
+* &= (x_N - x_0)(x_N - \bar{x}_{i+1} + x_0 - \bar{x}_{i})
+* \end{align*}
+* ```
+*
+* @param {Collection} [out] - output array
+* @param {PositiveInteger} window - window size
+* @throws {TypeError} output argument must be array-like
+* @throws {TypeError} window size must be a positive integer
+* @returns {Function} accumulator function
+*
+* @example
+* var accumulator = incrnanmmeanstdev( 3 );
+*
+* var v = accumulator();
+* // returns null
+*
+* v = accumulator( 2.0 );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( NaN );
+* // returns [ 2.0, 0.0 ]
+*
+* v = accumulator( -5.0 );
+* // returns [ -1.5, ~4.95 ]
+*
+* v = accumulator( 3.0 );
+* // returns [ 0.0, ~4.36 ]
+*
+* v = accumulator();
+* // returns [ 0.0, ~4.36 ]
+*/
+function incrnanmmeanstdev( out, window ) {
+ var mmeanstdev;
+
+ if ( arguments.length === 1 ) {
+ mmeanstdev = incrmmeanstdev( out );
+ } else {
+ mmeanstdev = incrmmeanstdev( out, window );
+ }
+ return accumulator;
+
+ /**
+ * If provided a value, the accumulator function returns updated accumulated values. If not provided a value, the accumulator function returns the current accumulated values.
+ *
+ * @private
+ * @param {number} [x] - input value
+ * @returns {(ArrayLikeObject|null)} output array or null
+ */
+ function accumulator( x ) {
+ if ( arguments.length === 0 || isnan( x ) ) {
+ return mmeanstdev();
+ }
+ return mmeanstdev( x );
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = incrnanmmeanstdev;
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/package.json b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/package.json
new file mode 100644
index 000000000000..7bbd667580ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/package.json
@@ -0,0 +1,80 @@
+{
+ "name": "@stdlib/stats/incr/nanmmeanstdev",
+ "version": "0.0.0",
+ "description": "Compute a moving arithmetic mean and corrected sample standard deviation 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",
+ "arithmetic mean",
+ "central tendency",
+ "moving mean",
+ "moving average",
+ "variance",
+ "sample",
+ "sample variance",
+ "unbiased",
+ "stdev",
+ "standard",
+ "deviation",
+ "dispersion",
+ "incremental",
+ "accumulator",
+ "sliding window",
+ "sliding",
+ "window",
+ "moving"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/test/test.js
new file mode 100644
index 000000000000..a2668d2f953c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/incr/nanmmeanstdev/test/test.js
@@ -0,0 +1,437 @@
+/**
+* @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 randu = require( '@stdlib/random/base/randu' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var incrnanmmeanstdev = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof incrnanmmeanstdev, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a positive integer for the window size', 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() {
+ incrnanmmeanstdev( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if not provided a positive integer for the window size', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ -5.0,
+ 0.0,
+ 3.14,
+ true,
+ false,
+ 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() {
+ incrnanmmeanstdev( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if not provided a positive integer for the window size (output)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ -5.0,
+ 0.0,
+ 3.14,
+ true,
+ false,
+ 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() {
+ incrnanmmeanstdev( [ 0.0, 0.0 ], value );
+ };
+ }
+});
+
+tape( 'the function throws an error if not provided an array-like object for an output argument', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ -5.0,
+ true,
+ false,
+ 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() {
+ incrnanmmeanstdev( value, 3 );
+ };
+ }
+});
+
+tape( 'the function returns an accumulator function', function test( t ) {
+ t.equal( typeof incrnanmmeanstdev( 3 ), 'function', 'returns a function' );
+ t.end();
+});
+
+tape( 'the function returns an accumulator function (output)', function test( t ) {
+ t.equal( typeof incrnanmmeanstdev( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+ t.end();
+});
+
+tape( 'the accumulator function computes a moving arithmetic mean and corrected sample standard deviation incrementally', function test( t ) {
+ var expected;
+ var actual;
+ var data;
+ var acc;
+ var N;
+ var i;
+
+ data = [ 2.0, 3.0, 4.0, -1.0, 3.0, 1.0 ];
+ N = data.length;
+
+ acc = incrnanmmeanstdev( 3 );
+
+ expected = [
+ [ 2.0, 0.0 ],
+ [ 2.5, sqrt( 0.5 ) ],
+ [ 3.0, sqrt( 1.0 ) ],
+ [ 2.0, sqrt( 7.0 ) ],
+ [ 2.0, sqrt( 7.0 ) ],
+ [ 1.0, sqrt( 4.0 ) ]
+ ];
+ for ( i = 0; i < N; i++ ) {
+ actual = acc( data[ i ] );
+ t.deepEqual( actual, expected[ i ], 'returns expected value' );
+ }
+ t.end();
+});
+
+tape( 'the accumulator function computes a moving arithmetic mean and corrected sample standard deviation incrementally (output)', function test( t ) {
+ var expected;
+ var actual;
+ var data;
+ var acc;
+ var out;
+ var N;
+ var i;
+
+ data = [ 2.0, 3.0, 4.0, -1.0, 3.0, 1.0 ];
+ N = data.length;
+
+ out = [ 0.0, 0.0 ];
+ acc = incrnanmmeanstdev( out, 3 );
+
+ expected = [
+ [ 2.0, 0.0 ],
+ [ 2.5, sqrt( 0.5 ) ],
+ [ 3.0, sqrt( 1.0 ) ],
+ [ 2.0, sqrt( 7.0 ) ],
+ [ 2.0, sqrt( 7.0 ) ],
+ [ 1.0, sqrt( 4.0 ) ]
+ ];
+ for ( i = 0; i < N; i++ ) {
+ actual = acc( data[ i ] );
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( actual, expected[ i ], 'returns expected value' );
+ }
+ t.end();
+});
+
+tape( 'if not provided an input value, the accumulator function returns the current arithmetic mean and corrected sample standard deviation', function test( t ) {
+ var expected;
+ var actual;
+ var delta;
+ var data;
+ var tol;
+ var acc;
+ var i;
+
+ data = [ 2.0, 3.0, 10.0 ];
+ acc = incrnanmmeanstdev( 3 );
+ for ( i = 0; i < data.length-1; i++ ) {
+ acc( data[ i ] );
+ }
+ t.deepEqual( acc(), [ 2.5, sqrt( 0.5 ) ], 'returns expected value' );
+
+ acc( data[ data.length-1 ] );
+
+ expected = [ 5.0, sqrt( 19.0 ) ];
+ actual = acc();
+
+ t.equal( actual[ 0 ], expected[ 0 ], 'returns expected value' );
+
+ delta = abs( actual[ 1 ] - expected[ 1 ] );
+ tol = EPS * expected[ 1 ];
+ t.equal( delta < tol, true, 'expected: '+expected[ 1 ]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+
+ t.end();
+});
+
+tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
+ var acc = incrnanmmeanstdev( 3 );
+ t.equal( acc(), null, 'returns null' );
+ t.end();
+});
+
+tape( 'if only one datum has been provided, the accumulator function returns `0` for the sample standard deviation', function test( t ) {
+ var acc = incrnanmmeanstdev( 3 );
+ var v = acc( 2.0 );
+ t.equal( v[ 0 ], 2.0, 'returns expected value' );
+ t.equal( v[ 1 ], 0.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if the window size is `1`, the accumulator functions always returns `0` for the sample standard deviation', function test( t ) {
+ var acc;
+ var out;
+ var v;
+ var i;
+
+ acc = incrnanmmeanstdev( 1 );
+ for ( i = 0; i < 100; i++ ) {
+ v = randu() * 100.0;
+ out = acc( v );
+ t.equal( out[ 0 ], v, 'returns expected value' );
+ t.equal( out[ 1 ], 0.0, 'returns expected value' );
+ }
+ t.end();
+});
+
+tape( 'if provided `NaN`, the accumulator returns current values or null', function test( t ) {
+ var expected;
+ var data;
+ var acc;
+ var v;
+ var i;
+
+ acc = incrnanmmeanstdev( 3 );
+
+ data = [
+ NaN,
+ 3.14, // 3.14
+ 3.14, // 3.14, 3.14
+ NaN, // 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ 3.14, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ NaN, // 3.14, 3.14, 3.14
+ 3.14 // 3.14, 3.14, 3.14
+ ];
+ expected = [
+ null,
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ]
+ ];
+ for ( i = 0; i < data.length; i++ ) {
+ v = acc( data[ i ] );
+ if ( i === 0 && isnan( data[ i ] ) ) {
+ t.equal( v, expected[ i ], 'returns expected value for window '+i );
+
+ v = acc();
+ t.equal( v, expected[ i ], 'returns expected value for window '+i );
+ } else {
+ if ( isnan( data[ i ] ) ) {
+ t.equal( isnan( v[ 0 ] ), false, 'returns expected value for window '+i );
+ t.equal( isnan( v[ 1 ] ), false, 'returns expected value for window '+i );
+ }
+
+ t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+ t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+
+ v = acc();
+ t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+ t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+ }
+ }
+ t.end();
+});
+
+tape( 'if provided `NaN`, the accumulator returns current values or null (W=1)', function test( t ) {
+ var expected;
+ var data;
+ var acc;
+ var v;
+ var i;
+
+ acc = incrnanmmeanstdev( 1 );
+
+ data = [
+ NaN,
+ 3.14,
+ 3.14,
+ NaN,
+ 3.14,
+ 3.14,
+ 3.14,
+ NaN,
+ 3.14,
+ 3.14,
+ 3.14,
+ NaN,
+ 3.14,
+ 3.14,
+ NaN,
+ NaN,
+ NaN,
+ NaN,
+ 3.14
+ ];
+ expected = [
+ null,
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ],
+ [ 3.14, 0.0 ]
+ ];
+ for ( i = 0; i < data.length; i++ ) {
+ v = acc( data[ i ] );
+ if ( i === 0 && isnan( data[ i ] ) ) {
+ t.equal( v, expected[ i ], 'returns expected value for window '+i );
+
+ v = acc();
+ t.equal( v, expected[ i ], 'returns expected value for window '+i );
+ } else {
+ if ( isnan( data[ i ] ) ) {
+ t.equal( isnan( v[ 0 ] ), false, 'returns expected value for window '+i );
+ t.equal( isnan( v[ 1 ] ), false, 'returns expected value for window '+i );
+ }
+
+ t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+ t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+
+ v = acc();
+ t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+ t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+ }
+ }
+ t.end();
+});