feat: add support for accessor arrays and refactor stats/base/meanpw

PR-URL: #7319
Closes: #5651
Reviewed-by: Athan Reines <[email protected]>

Author: gururaj1512

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

@@ -51,33 +51,29 @@ The [arithmetic mean][arithmetic-mean] is defined as
 var meanpw = require( '@stdlib/stats/base/meanpw' );
 ```
 
-#### meanpw( N, x, stride )
+#### meanpw( N, x, strideX )
 
-Computes the [arithmetic mean][arithmetic-mean] of a strided array `x` using pairwise summation.
+Computes the [arithmetic mean][arithmetic-mean] of a strided array using pairwise summation.
 
 ```javascript
 var x = [ 1.0, -2.0, 2.0 ];
-var N = x.length;
 
-var v = meanpw( N, x, 1 );
+var v = meanpw( x.length, x, 1 );
 // returns ~0.3333
 ```
 
 The function has the following parameters:
 
 -   **N**: number of indexed elements.
 -   **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 [arithmetic mean][arithmetic-mean] of every other element in `x`,
+The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to compute the [arithmetic mean][arithmetic-mean] of every other element in `x`,
 
 ```javascript
-var floor = require( '@stdlib/math/base/special/floor' );
-
 var x = [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ];
-var N = floor( x.length / 2 );
 
-var v = meanpw( N, x, 2 );
+var v = meanpw( 4, x, 2 );
 // returns 1.25
 ```
 
@@ -87,42 +83,35 @@ 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 ] );
 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-var N = floor( x0.length / 2 );
-
-var v = meanpw( N, x1, 2 );
+var v = meanpw( 4, x1, 2 );
 // returns 1.25
 ```
 
-#### meanpw.ndarray( N, x, stride, offset )
+#### meanpw.ndarray( N, x, strideX, offsetX )
 
 Computes the [arithmetic mean][arithmetic-mean] of a strided array using pairwise summation and alternative indexing semantics.
 
 ```javascript
 var x = [ 1.0, -2.0, 2.0 ];
-var N = x.length;
 
-var v = meanpw.ndarray( N, x, 1, 0 );
+var v = meanpw.ndarray( x.length, x, 1, 0 );
 // returns ~0.33333
 ```
 
 The function has the following additional parameters:
 
--   **offset**: starting index for `x`.
+-   **offsetX**: starting index for `x`.
 
-While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offset` parameter supports indexing semantics based on a starting index. For example, to calculate the [arithmetic mean][arithmetic-mean] for every other value in `x` starting from the second value
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to calculate the [arithmetic mean][arithmetic-mean] for every other element in `x` starting from the second element
 
 ```javascript
-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 = meanpw.ndarray( N, x, 2, 1 );
+var v = meanpw.ndarray( 4, x, 2, 1 );
 // returns 1.25
 ```
 
@@ -135,6 +124,7 @@ var v = meanpw.ndarray( N, x, 2, 1 );
 ## Notes
 
 -   If `N <= 0`, both functions return `NaN`.
+-   Both functions support array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]).
 -   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.
 -   Depending on the environment, the typed versions ([`dmeanpw`][@stdlib/stats/strided/dmeanpw], [`smeanpw`][@stdlib/stats/strided/smeanpw], etc.) are likely to be significantly more performant.
 
@@ -149,18 +139,12 @@ var v = meanpw.ndarray( N, 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 meanpw = require( '@stdlib/stats/base/meanpw' );
 
-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 = meanpw( x.length, x, 1 );
@@ -211,6 +195,8 @@ console.log( v );
 
 [@higham:1993a]: https://doi.org/10.1137/0914050
 
+[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
+
 <!-- <related-links> -->
 
 [@stdlib/stats/strided/dmeanpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dmeanpw

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

@@ -21,13 +21,20 @@
 // 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 meanpw = require( './../lib/meanpw.js' );
 
 
+// VARIABLES //
+
+var options = {
+	'dtype': 'generic'
+};
+
+
 // FUNCTIONS //
 
 /**
@@ -38,13 +45,7 @@ var meanpw = require( './../lib/meanpw.js' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var x;
-	var i;
-
-	x = [];
-	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*20.0 ) - 10.0 );
-	}
+	var x = uniform( len, -10, 10, options );
 	return benchmark;
 
 	function benchmark( b ) {

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

@@ -21,13 +21,20 @@
 // 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 meanpw = require( './../lib/ndarray.js' );
 
 
+// VARIABLES //
+
+var options = {
+	'dtype': 'generic'
+};
+
+
 // FUNCTIONS //
 
 /**
@@ -38,13 +45,7 @@ var meanpw = require( './../lib/ndarray.js' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var x;
-	var i;
-
-	x = [];
-	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*20.0 ) - 10.0 );
-	}
+	var x = uniform( len, -10, 10, options );
 	return benchmark;
 
 	function benchmark( b ) {

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

@@ -1,12 +1,12 @@
 
-{{alias}}( N, x, stride )
+{{alias}}( N, x, strideX )
     Computes the arithmetic mean of a strided array using pairwise summation.
 
     The `N` and `stride` parameters determine which elements in `x` are accessed
     at runtime.
 
-    Indexing is relative to the first index. To introduce an offset, use a typed
-    array view.
+    The `N` and stride parameters determine which elements in the strided array
+    are accessed at runtime.
 
     If `N <= 0`, the function returns `NaN`.
 
@@ -18,8 +18,8 @@
     x: Array<number>|TypedArray
         Input array.
 
-    stride: integer
-        Index increment.
+    strideX: integer
+        Stride length.
 
     Returns
     -------
@@ -33,22 +33,19 @@
     > {{alias}}( x.length, x, 1 )
     ~0.3333
 
-    // Using `N` and `stride` parameters:
+    // Using `N` and stride parameters:
     > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];
-    > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
-    > var stride = 2;
-    > {{alias}}( N, x, stride )
+    > {{alias}}( 3, x, 2 )
     ~0.3333
 
     // Using view offsets:
     > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
     > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
-    > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 );
-    > stride = 2;
-    > {{alias}}( N, x1, stride )
+    > {{alias}}( 3, x1, 2 )
     ~-0.3333
 
-{{alias}}.ndarray( N, x, stride, offset )
+
+{{alias}}.ndarray( N, x, strideX, offsetX )
     Computes the arithmetic mean of a strided array using pairwise summation and
     alternative indexing semantics.
 
@@ -64,10 +61,10 @@
     x: Array<number>|TypedArray
         Input array.
 
-    stride: integer
-        Index increment.
+    strideX: integer
+        Stride length.
 
-    offset: integer
+    offsetX: integer
         Starting index.
 
     Returns
@@ -84,8 +81,7 @@
 
     // Using offset parameter:
     > var x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];
-    > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
-    > {{alias}}.ndarray( N, x, 2, 1 )
+    > {{alias}}.ndarray( 3, x, 2, 1 )
     ~-0.3333
 
     See Also

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

@@ -20,7 +20,12 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { NumericArray } from '@stdlib/types/array';
+import { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array';
+
+/**
+* Input array.
+*/
+type InputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
 
 /**
 * Interface describing `meanpw`.
@@ -31,7 +36,7 @@ interface Routine {
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
-	* @param stride - stride length
+	* @param strideX - stride length
 	* @returns arithmetic mean
 	*
 	* @example
@@ -40,15 +45,15 @@ interface Routine {
 	* var v = meanpw( x.length, x, 1 );
 	* // returns ~0.3333
 	*/
-	( N: number, x: NumericArray, stride: number ): number;
+	( N: number, x: InputArray, strideX: number ): number;
 
 	/**
 	* Computes the arithmetic mean of a strided array using pairwise summation and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
-	* @param stride - stride length
-	* @param offset - starting index
+	* @param strideX - stride length
+	* @param offsetX - starting index
 	* @returns arithmetic mean
 	*
 	* @example
@@ -57,15 +62,15 @@ interface Routine {
 	* var v = meanpw.ndarray( x.length, x, 1, 0 );
 	* // returns ~0.3333
 	*/
-	ndarray( N: number, x: NumericArray, stride: number, offset: number ): number;
+	ndarray( N: number, x: InputArray, strideX: number, offsetX: number ): number;
 }
 
 /**
 * Computes the arithmetic mean of a strided array using pairwise summation.
 *
 * @param N - number of indexed elements
 * @param x - input array
-* @param stride - stride length
+* @param strideX - stride length
 * @returns arithmetic mean
 *
 * @example

lib/node_modules/@stdlib/stats/base/meanpw/docs/types/test.ts

@@ -16,6 +16,7 @@
 * limitations under the License.
 */
 
+import AccessorArray = require( '@stdlib/array/base/accessor' );
 import meanpw = require( './index' );
 
 
@@ -26,6 +27,7 @@ import meanpw = require( './index' );
 	const x = new Float64Array( 10 );
 
 	meanpw( x.length, x, 1 ); // $ExpectType number
+	meanpw( x.length, new AccessorArray( x ), 1 ); // $ExpectType number
 }
 
 // The compiler throws an error if the function is provided a first argument which is not a number...
@@ -85,6 +87,7 @@ import meanpw = require( './index' );
 	const x = new Float64Array( 10 );
 
 	meanpw.ndarray( x.length, x, 1, 0 ); // $ExpectType number
+	meanpw.ndarray( x.length, new AccessorArray( x ), 1, 0 ); // $ExpectType number
 }
 
 // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...

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

@@ -18,18 +18,12 @@
 
 '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 meanpw = require( './../lib' );
 
-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 = meanpw( x.length, x, 1 );