refactor: add protocol support to stats/base/variancewd

Author: gkbishnoi07

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

@@ -98,7 +98,7 @@ The use of the term `n-1` is commonly referred to as Bessel's correction. Note,
 var variancewd = require( '@stdlib/stats/base/variancewd' );
 ```
 
-#### variancewd( N, correction, x, stride )
+#### variancewd( N, correction, x, strideX )
 
 Computes the [variance][variance] of a strided array `x` using Welford's algorithm.
 
@@ -114,9 +114,9 @@ The function has the following parameters:
 -   **N**: number of indexed elements.
 -   **correction**: degrees of freedom adjustment. Setting this parameter to a value other than `0` has the effect of adjusting the divisor during the calculation of the [variance][variance] according to `N-c` where `c` corresponds to the provided degrees of freedom adjustment. When computing the [variance][variance] of a population, setting this parameter to `0` is the standard choice (i.e., the provided array contains data constituting an entire population). When computing the unbiased sample [variance][variance], setting this parameter to `1` is the standard choice (i.e., the provided array contains data sampled from a larger population; this is commonly referred to as Bessel's correction).
 -   **x**: input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
--   **stride**: index increment for `x`.
+-   **strideX**: stride length for `x`.
 
-The `N` and `stride` parameters determine which elements in `x` are accessed at runtime. For example, to compute the [variance][variance] of every other element in `x`,
+The `N` and `strideX` parameters determine which elements in `x` are accessed at runtime. For example, to compute the [variance][variance] of every other element in `x`,
 
 ```javascript
 var floor = require( '@stdlib/math/base/special/floor' );
@@ -145,7 +145,7 @@ var v = variancewd( N, 1, x1, 2 );
 // returns 6.25
 ```
 
-#### variancewd.ndarray( N, correction, x, stride, offset )
+#### variancewd.ndarray( N, correction, x, strideX, offset )
 
 Computes the [variance][variance] of a strided array using Welford's algorithm and alternative indexing semantics.
 
@@ -195,18 +195,15 @@ var v = variancewd.ndarray( N, 1, x, 2, 1 );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var randu = require( '@stdlib/random/base/randu' );
-var round = require( '@stdlib/math/base/special/round' );
-var Float64Array = require( '@stdlib/array/float64' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var variancewd = require( '@stdlib/stats/base/variancewd' );
 
 var x;
 var i;
 
-x = new Float64Array( 10 );
-for ( i = 0; i < x.length; i++ ) {
-    x[ i ] = round( (randu()*100.0) - 50.0 );
-}
+var x = discreteUniform( 10, -50, 50, {
+    'dtype': 'float64'
+});
 console.log( x );
 
 var v = variancewd( x.length, 1, x, 1 );
@@ -267,6 +264,8 @@ console.log( v );
 
 [@stdlib/stats/base/dvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/dvariancewd
 
+[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
+
 [@stdlib/stats/base/nanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/nanvariancewd
 
 [@stdlib/stats/base/stdevwd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/stdevwd

lib/node_modules/@stdlib/stats/base/variancewd/benchmark/benchmark.js

@@ -21,12 +21,17 @@
 // MODULES //
 
 var bench = require( '@stdlib/bench' );
-var randu = require( '@stdlib/random/base/randu' );
+var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
 var variancewd = require( './../lib/variancewd.js' );
 
+// VARIABLES //
+
+var options = {
+    'dtype': 'generic'
+}; // FIXED: Added `options` variable
 
 // FUNCTIONS //
 
@@ -41,10 +46,8 @@ function createBenchmark( len ) {
 	var x;
 	var i;
 
-	x = [];
-	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*20.0 ) - 10.0 );
-	}
+	x = uniform( len, -10.0, 10.0, options ); // FIXED: Added `options`
+
 	return benchmark;
 
 	function benchmark( b ) {

lib/node_modules/@stdlib/stats/base/variancewd/benchmark/benchmark.ndarray.js

@@ -21,12 +21,18 @@
 // MODULES //
 
 var bench = require( '@stdlib/bench' );
-var randu = require( '@stdlib/random/base/randu' );
+var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
 var variancewd = require( './../lib/ndarray.js' );
 
+// VARIABLES //
+
+var options = {
+    'dtype': 'generic'
+};
+
 
 // FUNCTIONS //
 
@@ -41,10 +47,7 @@ function createBenchmark( len ) {
 	var x;
 	var i;
 
-	x = [];
-	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*20.0 ) - 10.0 );
-	}
+	x = uniform( len, -10.0, 10.0, options ); // FIXED: Added `options`
 	return benchmark;
 
 	function benchmark( b ) {

lib/node_modules/@stdlib/stats/base/variancewd/docs/types/index.d.ts

@@ -32,7 +32,7 @@ interface Routine {
 	* @param N - number of indexed elements
 	* @param correction - degrees of freedom adjustment
 	* @param x - input array
-	* @param stride - stride length
+	* @param strideX - stride length
 	* @returns variance
 	*
 	* @example
@@ -41,16 +41,16 @@ interface Routine {
 	* var v = variancewd( x.length, 1, x, 1 );
 	* // returns ~4.3333
 	*/
-	( N: number, correction: number, x: NumericArray, stride: number ): number;
+	( N: number, correction: number, x: NumericArray, strideX: number ): number;
 
 	/**
 	* Computes the variance of a strided array using Welford's algorithm and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param correction - degrees of freedom adjustment
 	* @param x - input array
-	* @param stride - stride length
-	* @param offset - starting index
+	* @param strideX - stride length
+	* @param offsetX - starting index
 	* @returns variance
 	*
 	* @example
@@ -59,7 +59,7 @@ interface Routine {
 	* var v = variancewd.ndarray( x.length, 1, x, 1, 0 );
 	* // returns ~4.3333
 	*/
-	ndarray( N: number, correction: number, x: NumericArray, stride: number, offset: number ): number;
+	ndarray( N: number, correction: number, x: NumericArray, strideX: number, offsetX: number ): number;
 }
 
 /**
@@ -68,7 +68,7 @@ interface Routine {
 * @param N - number of indexed elements
 * @param correction - degrees of freedom adjustment
 * @param x - input array
-* @param stride - stride length
+* @param strideX - stride length
 * @returns variance
 *
 * @example

lib/node_modules/@stdlib/stats/base/variancewd/examples/index.js

@@ -18,18 +18,13 @@
 
 'use strict';
 
-var randu = require( '@stdlib/random/base/randu' );
-var round = require( '@stdlib/math/base/special/round' );
-var Float64Array = require( '@stdlib/array/float64' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var variancewd = require( './../lib' );
 
-var x;
-var i;
+var x = discreteUniform( 10, -50, 50, {
+    'dtype': 'float64'
+});
 
-x = new Float64Array( 10 );
-for ( i = 0; i < x.length; i++ ) {
-	x[ i ] = round( (randu()*100.0) - 50.0 );
-}
 console.log( x );
 
 var v = variancewd( x.length, 1, x, 1 );

lib/node_modules/@stdlib/stats/base/variancewd/lib/accessors.js

@@ -0,0 +1,71 @@
+/**
+* @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.
+*/
+
+/**
+* Computes the variance of a strided array using Welford's algorithm and accessors.
+*
+* @private
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} correction - degrees of freedom adjustment
+* @param {Object} x - input array object
+* @param {Collection} x.data - input array data
+* @param {Array<Function>} x.accessors - array element accessors
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {number} variance
+*/
+function variancewd(N, correction, x, strideX, offsetX) {
+    var xbuf;
+    var get;
+    var delta;
+    var delta2;
+    var mu;
+    var M2;
+    var ix;
+    var v;
+    var n;
+    var i;
+
+    n = N - correction;
+    if (N <= 0 || n <= 0.0) {
+        return NaN;
+    }
+    if (N === 1 || strideX === 0) {
+        return 0.0;
+    }
+
+    xbuf = x.data;
+    get = x.accessors[0];
+
+    ix = offsetX;
+    M2 = 0.0;
+    mu = 0.0;
+
+    for (i = 0; i < N; i++) {
+        v = get(xbuf, ix);
+        delta = v - mu;
+        mu += delta / (i + 1);
+        delta2 = v - mu;
+        M2 += delta * delta2;
+        ix += strideX;
+    }
+
+    return M2 / n;
+}
+
+module.exports = variancewd;

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

@@ -45,11 +45,12 @@
 
 // MODULES //
 
-var main = require( './main.js' );
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var variancewd = require( './variancewd.js' );
+var ndarray = require( './ndarray.js' );
 
+// MAIN //
+setReadOnly( variancewd, 'ndarray', ndarray );
 
 // EXPORTS //
-
-module.exports = main;
-
-// exports: { "ndarray": "main.ndarray" }
+module.exports = variancewd;

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

@@ -18,6 +18,10 @@
 
 'use strict';
 
+// MODULES //
+var arraylike2object = require( '@stdlib/array/base/arraylike2object' );
+var accessors = require( './accessors.js' );
+
 // MAIN //
 
 /**
@@ -62,49 +66,60 @@
 * -   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).
 *
+/**
+* Computes the variance of a strided array using Welford's algorithm.
+*
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} correction - degrees of freedom adjustment
 * @param {NumericArray} x - input array
-* @param {integer} stride - stride length
-* @param {NonNegativeInteger} offset - starting index
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
 * @returns {number} variance
-*
-* @example
-* var floor = require( '@stdlib/math/base/special/floor' );
-*
-* var x = [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ];
-* var N = floor( x.length / 2 );
-*
-* var v = variancewd( N, 1, x, 2, 1 );
-* // returns 6.25
 */
-function variancewd( N, correction, x, stride, offset ) {
-	var delta;
-	var mu;
-	var M2;
-	var ix;
-	var v;
-	var n;
-	var i;
+function variancewd(N, correction, x, strideX, offsetX) {
+    var delta;
+    var delta2;
+    var mu;
+    var M2;
+    var ix;
+    var v;
+    var n;
+    var o;
+    var i;
+
+    if (N <= 0) {
+        return NaN;
+    }
+    if (N === 1 || strideX === 0) {
+        if (N - correction <= 0) {
+            return NaN;
+        }
+        return 0.0;
+    }
+    n = N - correction;
+    if (n <= 0) {
+        return NaN;
+    }
+
+    o = arraylike2object(x);
+    if (o.accessorProtocol) {
+        return accessors(N, correction, o, strideX, offsetX);
+    }
+
+    ix = offsetX;
+    M2 = 0.0;
+    mu = 0.0;
+
+    for (i = 0; i < N; i++) {
+        v = o.data[ix];
+        delta = v - mu;
+        mu += delta / (i + 1);
+        delta2 = v - mu;  // Calculate second delta after mean is updated
+        M2 += delta * delta2;
+        ix += strideX;
+    }
 
-	n = N - correction;
-	if ( N <= 0 || n <= 0.0 ) {
-		return NaN;
-	}
-	if ( N === 1 || stride === 0 ) {
-		return 0.0;
-	}
-	ix = offset;
-	M2 = 0.0;
-	mu = 0.0;
-	for ( i = 0; i < N; i++ ) {
-		v = x[ ix ];
-		delta = v - mu;
-		mu += delta / (i+1);
-		M2 += delta * ( v - mu );
-		ix += stride;
-	}
-	return M2 / n;
+    return M2 / n;
 }