chore: minor clean up

Author: Neerajpathak07

lib/node_modules/@stdlib/stats/base/dnanmeanwd/README.md

@@ -74,11 +74,10 @@ The `N` and stride parameters determine which elements in the stride array are a
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
-var floor = require( '@stdlib/math/base/special/floor' );
 
 var x = new Float64Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN ] );
 
-var v = dnanmeanwd( 5, x, 2 );
+var v = dnanmeanwd( 4, x, 2 );
 // returns 1.25
 ```
 
@@ -88,10 +87,12 @@ Note that indexing is relative to the first index. To introduce an offset, use [
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
-var floor = require( '@stdlib/math/base/special/floor' );
 
 var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+var v = dnanmeanwd( 4, x1, 2 );
+// returns 1.25
 ```
 
 #### dnanmeanwd.ndarray( N, x, strideX, offsetX )
@@ -117,6 +118,9 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the
 var Float64Array = require( '@stdlib/array/float64' );
 
 var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
+
+var v = dnanmeanwd( 4, x, 2, 1 );
+// returns 1.25
 ```
 
 </section>
@@ -195,13 +199,13 @@ console.log( v );
 
 #### stdlib_strided_dnanmeanwd( N, \*X, strideX )
 
-Computes the mean value of a double-precision floating-point strided array `x`, ignoring `NaN` values.
+Computes the arithmetic mean of a double-precision floating-point strided array `x`, using Welford's algorithm and ignoring `NaN` values.
 
 ```c
-const double x[] = { 1.0, 0.0/0.0, 3.0, -4.0 };
+const double x[] = { 1.0, 2.0, 0.0/0.0, 3.0, 0.0/0.0, 4.0, 5.0, 6.0, 0.0/0.0, 7.0, 8.0, 0.0/0.0 };
 
-double v = stdlib_strided_dnanmeanwd( 5, x, 1 );
-// returns 0.3333
+double v = stdlib_strided_dnanmeanwd( 6, x, 2 );
+// returns 1.25
 ```
 
 The function accepts the following arguments:
@@ -216,13 +220,13 @@ double stdlib_strided_dnanmeanwd( const CBLAS_INT N, const double *X, const CBLA
 
 #### stdlib_strided_dnanmeanwd_ndarray( N, \*X, strideX, offsetX )
 
-Computes the mean value of a double-precision floating-point strided array, ignoring `NaN` values and using alternative indexing semantics.
+Computes the arithmetic mean of a double-precision floating-point strided array, ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics.
 
 ```c
-const double x[] = { 1.0, 0.0/0.0, 3.0, -4.0 };
+const double x[] = { 1.0, 2.0, 0.0/0.0, 3.0, 0.0/0.0, 4.0, 5.0, 6.0, 0.0/0.0, 7.0, 8.0, 0.0/0.0 };
 
-double v = stdlib_strided_dnanmeanwd_ndarray( 5, x, 1, 0 );
-// returns 7.0
+double v = stdlib_strided_dnanmeanwd_ndarray( 6, x, 2, 0 );
+// returns 1.25
 ```
 
 The function accepts the following arguments:

lib/node_modules/@stdlib/stats/base/dnanmeanwd/docs/repl.txt

@@ -3,8 +3,8 @@
     Computes the arithmetic mean of a double-precision floating-point strided
     array, using Welford's algorithm and ignoring `NaN` values.
 
-    The `N` and stride parameters determine which elements in `x` are accessed
-    at runtime.
+    The `N` and stride parameters determine which elements in the strided array
+    are accessed at runtime.
 
     Indexing is relative to the first index. To introduce an offset, use a typed
     array view.
@@ -22,7 +22,7 @@
         Input array.
 
     strideX: integer
-        Stride Length.
+        Stride length.
 
     Returns
     -------
@@ -54,7 +54,7 @@
     indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
-    buffer, the `offset` parameter supports indexing semantics based on a
+    buffer, the offset parameter supports indexing semantics based on a
     starting index.
 
     Parameters
@@ -66,7 +66,7 @@
         Input array.
 
     strideX: integer
-        Stride Length.
+        Stride length.
 
     offsetX: integer
         Starting index.

lib/node_modules/@stdlib/stats/base/dnanmeanwd/include/stdlib/stats/base/dnanmeanwd.h

@@ -34,7 +34,7 @@ extern "C" {
 double API_SUFFIX(stdlib_strided_dnanmeanwd)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX );
 
 /**
-* Computes the maximum absolute value of a double-precision floating-point strided array, ignoring `NaN` values and using alternative indexing semantics .
+* Computes the arithmetic mean of a double-precision floating-point strided array, ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics.
 */
 double API_SUFFIX(stdlib_strided_dnanmeanwd_ndarray)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 

lib/node_modules/@stdlib/stats/base/dnanmeanwd/lib/dnanmeanwd.js

@@ -54,7 +54,6 @@ var ndarray = require( './ndarray.js' );
 * var Float64Array = require( '@stdlib/array/float64' );
 *
 * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-* var N = x.length;
 *
 * var v = dnanmeanwd( x.length, x, 1 );
 * // returns ~0.3333

lib/node_modules/@stdlib/stats/base/dnanmeanwd/lib/dnanmeanwd.native.js

@@ -37,7 +37,6 @@ var addon = require( './../src/addon.node' );
 * var Float64Array = require( '@stdlib/array/float64' );
 *
 * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-* var N = x.length;
 *
 * var v = dnanmeanwd( x.length, x, 1 );
 * // returns ~0.3333

lib/node_modules/@stdlib/stats/base/dnanmeanwd/lib/index.js

@@ -28,9 +28,8 @@
 * var dnanmeanwd = require( '@stdlib/stats/base/dnanmeanwd' );
 *
 * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-* var N = 3;
 *
-* var v = dnanmeanwd( 5, x, 1 );
+* var v = dnanmeanwd( x.length, x, 1 );
 * // returns ~0.3333
 *
 * @example
@@ -39,7 +38,7 @@
 *
 * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
 *
-* var v = dnanmeanwd.ndarray( 5, x, 2, 1 );
+* var v = dnanmeanwd.ndarray( 4, x, 2, 1 );
 * // returns 1.25
 */
 

lib/node_modules/@stdlib/stats/base/dnanmeanwd/lib/ndarray.js

@@ -52,6 +52,8 @@
 *
 * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
 *
+* var v = dnanmeanwd( 4, x, 2, 1 );
+* // returns 1.25
 */
 function dnanmeanwd( N, x, strideX, offsetX ) {
 	var mu;

lib/node_modules/@stdlib/stats/base/dnanmeanwd/lib/ndarray.native.js

@@ -39,6 +39,8 @@ var addon = require( './../src/addon.node' );
 *
 * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
 *
+* var v = dnanmeanwd( 4, x, 2, 1 );
+* // returns 1.25
 */
 function dnanmeanwd( N, x, strideX, offsetX ) {
 	return addon.ndarray( N, x, strideX, offsetX );

lib/node_modules/@stdlib/stats/base/dnanmeanwd/src/main.c

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2020 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -42,18 +42,18 @@
 * -   Welford, B. P. 1962. "Note on a Method for Calculating Corrected Sums of Squares and Products." _Technometrics_ 4 (3). Taylor & Francis: 419–20. doi:[10.1080/00401706.1962.10490022](https://doi.org/10.1080/00401706.1962.10490022).
 * -   van Reeken, A. J. 1968. "Letters to the Editor: Dealing with Neely's Algorithms." _Communications of the ACM_ 11 (3): 149–50. doi:[10.1145/362929.362961](https://doi.org/10.1145/362929.362961).
 *
-* @param N       number of indexed elements
-* @param X       input array
+* @param N        number of indexed elements
+* @param X        input array
 * @param strideX  stride length
-* @return        output value
+* @return         output value
 */
 double API_SUFFIX(stdlib_strided_dnanmeanwd)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX ) {
 	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	return API_SUFFIX(stdlib_strided_dnanmeanwd_ndarray)( N, X, strideX, ox );
 }
 
 /**
-* Computes the maximum absolute value of a double-precision floating-point strided array, ignoring `NaN` values and using alternative indexing semantics.
+* Computes the arithmetic mean of a double-precision floating-point strided array, ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics.
 *
 * @param N        number of indexed elements
 * @param X        input array
@@ -72,13 +72,9 @@ double API_SUFFIX(stdlib_strided_dnanmeanwd_ndarray)( const CBLAS_INT N, const d
 		return 0.0 / 0.0; // NaN
 	}
 	if ( N == 1 || strideX == 0 ) {
-		return X[ 0 ];
-	}
-	if ( strideX < 0 ) {
-		ix = (1-N) * strideX;
-	} else {
-		ix = 0;
+		return X[ offsetX ];
 	}
+	ix = offsetX;
 	mu = 0.0;
 	n = 0;
 	for ( i = 0; i < N; i++ ) {

lib/node_modules/@stdlib/stats/base/dnanmeanwd/test/test.dnanmeanwd.js

@@ -104,7 +104,7 @@ tape( 'the function supports a `stride` parameter', function test( t ) {
 		NaN   // 4
 	]);
 
-	v = dnanmeanwd( 5, x, 2 );
+	v = dnanmeanwd( 4, x, 2 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();
@@ -126,7 +126,7 @@ tape( 'the function supports a negative `stride` parameter', function test( t )
 		NaN   // 0
 	]);
 
-	v = dnanmeanwd( 5, x, -2 );
+	v = dnanmeanwd( 4, x, -2 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();