diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/README.md b/lib/node_modules/@stdlib/stats/base/meanpw/README.md
index af39f5e06eac..8c0f6355f46c 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/README.md
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/README.md
@@ -51,15 +51,14 @@ 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
 ```
 
@@ -67,17 +66,14 @@ 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
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.js
index 11d69160732e..57d3fe133e9e 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.js
+++ b/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 ) {
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.ndarray.js
index c2f01c79ac42..94589cc07a6d 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/benchmark/benchmark.ndarray.js
+++ 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 ) {
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/meanpw/docs/repl.txt
index 33d6811f3289..598c7394d85b 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/docs/repl.txt
+++ 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
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/index.d.ts
index 50b60ecda4e9..427176f159df 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/index.d.ts
+++ b/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,7 +62,7 @@ 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;
 }
 
 /**
@@ -65,7 +70,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
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/test.ts
index ecd76bde62d0..31a97989229a 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/docs/types/test.ts
+++ b/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...
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/examples/index.js b/lib/node_modules/@stdlib/stats/base/meanpw/examples/index.js
index bd11b4f9d88c..f0765444b493 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/examples/index.js
+++ b/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 );
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/lib/index.js b/lib/node_modules/@stdlib/stats/base/meanpw/lib/index.js
index 74facb9a8f47..39d7a4c72f58 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/lib/index.js
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/lib/index.js
@@ -27,19 +27,16 @@
 * var meanpw = require( '@stdlib/stats/base/meanpw' );
 *
 * 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
 *
 * @example
-* var floor = require( '@stdlib/math/base/special/floor' );
 * var meanpw = require( '@stdlib/stats/base/meanpw' );
 *
 * 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( x.length, x, 2, 1 );
 * // returns 1.25
 */
 
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/lib/meanpw.js b/lib/node_modules/@stdlib/stats/base/meanpw/lib/meanpw.js
index aa585399ee9a..67edf5533883 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/lib/meanpw.js
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/lib/meanpw.js
@@ -20,7 +20,8 @@
 
 // MODULES //
 
-var gsumpw = require( '@stdlib/blas/ext/base/gsumpw' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
@@ -30,24 +31,17 @@ var gsumpw = require( '@stdlib/blas/ext/base/gsumpw' );
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {NumericArray} x - input array
-* @param {integer} stride - stride length
+* @param {integer} strideX - stride length
 * @returns {number} arithmetic mean
 *
 * @example
 * 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
 */
-function meanpw( N, x, stride ) {
-	if ( N <= 0 ) {
-		return NaN;
-	}
-	if ( N === 1 || stride === 0 ) {
-		return x[ 0 ];
-	}
-	return gsumpw( N, x, stride ) / N;
+function meanpw( N, x, strideX ) {
+	return ndarray( N, x, strideX, stride2offset( N, strideX ) );
 }
 
 
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/lib/ndarray.js b/lib/node_modules/@stdlib/stats/base/meanpw/lib/ndarray.js
index 7200e789f37a..c78f7bb65760 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/lib/ndarray.js
@@ -30,27 +30,21 @@ var gsumpw = require( '@stdlib/blas/ext/base/gsumpw' ).ndarray;
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @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} arithmetic mean
 *
 * @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 = meanpw( N, x, 2, 1 );
+* var v = meanpw( 4, x, 2, 1 );
 * // returns 1.25
 */
-function meanpw( N, x, stride, offset ) {
+function meanpw( N, x, strideX, offsetX ) {
 	if ( N <= 0 ) {
 		return NaN;
 	}
-	if ( N === 1 || stride === 0 ) {
-		return x[ offset ];
-	}
-	return gsumpw( N, x, stride, offset ) / N;
+	return gsumpw( N, x, strideX, offsetX ) / N;
 }
 
 
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/test/test.meanpw.js b/lib/node_modules/@stdlib/stats/base/meanpw/test/test.meanpw.js
index 4a1dacbeef13..5ecaa677a6de 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/test/test.meanpw.js
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/test/test.meanpw.js
@@ -21,10 +21,10 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var floor = require( '@stdlib/math/base/special/floor' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var Float64Array = require( '@stdlib/array/float64' );
-var meanpw = require( './../lib/meanpw.js' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var meanpw = require( './../lib/main.js' );
 
 
 // TESTS //
@@ -57,6 +57,23 @@ tape( 'the function calculates the arithmetic mean of a strided array', function
 	t.end();
 });
 
+tape( 'the function calculates the arithmetic mean of a strided array (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 1 );
+	t.strictEqual( v, 0.5, 'returns expected value' );
+
+	x = [ -4.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 1 );
+	t.strictEqual( v, -4.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) {
 	var x;
 	var v;
@@ -72,6 +89,21 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 	t.end();
 });
 
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN` (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( 0, toAccessorArray( x ), 1 );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	v = meanpw( -1, toAccessorArray( x ), 1 );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'if provided an `N` parameter equal to `1`, the function returns the first element', function test( t ) {
 	var x;
 	var v;
@@ -84,8 +116,19 @@ tape( 'if provided an `N` parameter equal to `1`, the function returns the first
 	t.end();
 });
 
+tape( 'if provided an `N` parameter equal to `1`, the function returns the first element (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( 1, toAccessorArray( x ), 1 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports a `stride` parameter', function test( t ) {
-	var N;
 	var x;
 	var v;
 
@@ -100,15 +143,34 @@ tape( 'the function supports a `stride` parameter', function test( t ) {
 		2.0
 	];
 
-	N = floor( x.length / 2 );
-	v = meanpw( N, x, 2 );
+	v = meanpw( 4, x, 2 );
+
+	t.strictEqual( v, 1.25, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `stride` parameter (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	];
+
+	v = meanpw( 4, toAccessorArray( x ), 2 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function supports a negative `stride` parameter', function test( t ) {
-	var N;
 	var x;
 	var v;
 
@@ -123,8 +185,28 @@ tape( 'the function supports a negative `stride` parameter', function test( t )
 		2.0
 	];
 
-	N = floor( x.length / 2 );
-	v = meanpw( N, x, -2 );
+	v = meanpw( 4, x, -2 );
+
+	t.strictEqual( v, 1.25, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a negative `stride` parameter (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	];
+
+	v = meanpw( 4, toAccessorArray( x ), -2 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();
@@ -142,10 +224,21 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns the f
 	t.end();
 });
 
+tape( 'if provided a `stride` parameter equal to `0`, the function returns the first element (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 0 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports view offsets', function test( t ) {
 	var x0;
 	var x1;
-	var N;
 	var v;
 
 	x0 = new Float64Array([
@@ -161,9 +254,33 @@ tape( 'the function supports view offsets', function test( t ) {
 	]);
 
 	x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
-	N = floor(x1.length / 2);
 
-	v = meanpw( N, x1, 2 );
+	v = meanpw( 4, x1, 2 );
+	t.strictEqual( v, 1.25, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports view offsets (accessors)', function test( t ) {
+	var x0;
+	var x1;
+	var v;
+
+	x0 = new Float64Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0,  // 3
+		6.0
+	]);
+
+	x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+	v = meanpw( 4, toAccessorArray( x1 ), 2 );
 	t.strictEqual( v, 1.25, 'returns expected value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/meanpw/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/base/meanpw/test/test.ndarray.js
index 07a3c93f9d73..7985b69bae8d 100644
--- a/lib/node_modules/@stdlib/stats/base/meanpw/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/stats/base/meanpw/test/test.ndarray.js
@@ -21,8 +21,8 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var floor = require( '@stdlib/math/base/special/floor' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var meanpw = require( './../lib/ndarray.js' );
 
 
@@ -56,6 +56,23 @@ tape( 'the function calculates the arithmetic mean of a strided array', function
 	t.end();
 });
 
+tape( 'the function calculates the arithmetic mean of a strided array (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 1, 0 );
+	t.strictEqual( v, 0.5, 'returns expected value' );
+
+	x = [ -4.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 1, 0 );
+	t.strictEqual( v, -4.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) {
 	var x;
 	var v;
@@ -71,6 +88,21 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 	t.end();
 });
 
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN` (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( 0, toAccessorArray( x ), 1, 0 );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	v = meanpw( -1, toAccessorArray( x ), 1, 0 );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'if provided an `N` parameter equal to `1`, the function returns the first indexed element', function test( t ) {
 	var x;
 	var v;
@@ -83,8 +115,19 @@ tape( 'if provided an `N` parameter equal to `1`, the function returns the first
 	t.end();
 });
 
+tape( 'if provided an `N` parameter equal to `1`, the function returns the first indexed element (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( 1, toAccessorArray( x ), 1, 0 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports a `stride` parameter', function test( t ) {
-	var N;
 	var x;
 	var v;
 
@@ -99,15 +142,34 @@ tape( 'the function supports a `stride` parameter', function test( t ) {
 		2.0
 	];
 
-	N = floor( x.length / 2 );
-	v = meanpw( N, x, 2, 0 );
+	v = meanpw( 4, x, 2, 0 );
+
+	t.strictEqual( v, 1.25, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `stride` parameter (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	];
+
+	v = meanpw( 4, toAccessorArray( x ), 2, 0 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function supports a negative `stride` parameter', function test( t ) {
-	var N;
 	var x;
 	var v;
 
@@ -122,8 +184,28 @@ tape( 'the function supports a negative `stride` parameter', function test( t )
 		2.0
 	];
 
-	N = floor( x.length / 2 );
-	v = meanpw( N, x, -2, 6 );
+	v = meanpw( 4, x, -2, 6 );
+
+	t.strictEqual( v, 1.25, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a negative `stride` parameter (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	];
+
+	v = meanpw( 4, toAccessorArray( x ), -2, 6 );
 
 	t.strictEqual( v, 1.25, 'returns expected value' );
 	t.end();
@@ -141,8 +223,19 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns the f
 	t.end();
 });
 
+tape( 'if provided a `stride` parameter equal to `0`, the function returns the first indexed element (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
+
+	v = meanpw( x.length, toAccessorArray( x ), 0, 0 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports an `offset` parameter', function test( t ) {
-	var N;
 	var x;
 	var v;
 
@@ -156,9 +249,29 @@ tape( 'the function supports an `offset` parameter', function test( t ) {
 		3.0,
 		4.0   // 3
 	];
-	N = floor( x.length / 2 );
 
-	v = meanpw( N, x, 2, 1 );
+	v = meanpw( 4, x, 2, 1 );
+	t.strictEqual( v, 1.25, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports an `offset` parameter (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	];
+
+	v = meanpw( 4, toAccessorArray( x ), 2, 1 );
 	t.strictEqual( v, 1.25, 'returns expected value' );
 
 	t.end();