Skip to content

Commit 9323351

Browse files
gururaj1512kgryte
gururaj1512
and
kgryte
authored
feat: add support for accessor arrays and refactor stats/base/nanmeanpn
PR-URL: #7098 Closes: #5657 Co-authored-by: Athan Reines <kgryte@gmail.com> Reviewed-by: Athan Reines <kgryte@gmail.com>
1 parent 0f9285b commit 9323351

File tree

13 files changed

+428
-169
lines changed

13 files changed

+428
-169
lines changed

‎lib/node_modules/@stdlib/stats/base/nanmeanpn/README.md

Lines changed: 28 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -51,78 +51,67 @@ The [arithmetic mean][arithmetic-mean] is defined as
5151
var nanmeanpn = require( '@stdlib/stats/base/nanmeanpn' );
5252
```
5353

54-
#### nanmeanpn( N, x, stride )
54+
#### nanmeanpn( N, x, strideX )
5555

56-
Computes the [arithmetic mean][arithmetic-mean] of a strided array `x`, ignoring `NaN` values and using a two-pass error correction algorithm.
56+
Computes the [arithmetic mean][arithmetic-mean] of a strided array, ignoring `NaN` values and using a two-pass error correction algorithm.
5757

5858
```javascript
5959
var x = [ 1.0, -2.0, NaN, 2.0 ];
60-
var N = x.length;
6160

62-
var v = nanmeanpn( N, x, 1 );
61+
var v = nanmeanpn( x.length, x, 1 );
6362
// returns ~0.3333
6463
```
6564

6665
The function has the following parameters:
6766

6867
- **N**: number of indexed elements.
6968
- **x**: input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
70-
- **stride**: index increment for `x`.
69+
- **strideX**: stride length for `x`.
7170

72-
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`,
71+
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`,
7372

7473
```javascript
75-
var floor = require( '@stdlib/math/base/special/floor' );
76-
77-
var x = [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN ];
78-
var N = floor( x.length / 2 );
74+
var x = [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN, NaN ];
7975

80-
var v = nanmeanpn( N, x, 2 );
76+
var v = nanmeanpn( 5, x, 2 );
8177
// returns 1.25
8278
```
8379

8480
Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
8581

86-
<!-- eslint-disable stdlib/capitalized-comments -->
82+
<!-- eslint-disable stdlib/capitalized-comments, max-len -->
8783

8884
```javascript
8985
var Float64Array = require( '@stdlib/array/float64' );
90-
var floor = require( '@stdlib/math/base/special/floor' );
9186

92-
var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ] );
87+
var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );
9388
var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
9489

95-
var N = floor( x0.length / 2 );
96-
97-
var v = nanmeanpn( N, x1, 2 );
90+
var v = nanmeanpn( 5, x1, 2 );
9891
// returns 1.25
9992
```
10093

101-
#### nanmeanpn.ndarray( N, x, stride, offset )
94+
#### nanmeanpn.ndarray( N, x, strideX, offsetX )
10295

10396
Computes the [arithmetic mean][arithmetic-mean] of a strided array, ignoring `NaN` values and using a two-pass error correction algorithm and alternative indexing semantics.
10497

10598
```javascript
10699
var x = [ 1.0, -2.0, NaN, 2.0 ];
107-
var N = x.length;
108100

109-
var v = nanmeanpn.ndarray( N, x, 1, 0 );
101+
var v = nanmeanpn.ndarray( x.length, x, 1, 0 );
110102
// returns ~0.33333
111103
```
112104

113105
The function has the following additional parameters:
114106

115-
- **offset**: starting index for `x`.
107+
- **offsetX**: starting index for `x`.
116108

117-
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
109+
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
118110

119111
```javascript
120-
var floor = require( '@stdlib/math/base/special/floor' );
121-
122-
var x = [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN ];
123-
var N = floor( x.length / 2 );
112+
var x = [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ];
124113

125-
var v = nanmeanpn.ndarray( N, x, 2, 1 );
114+
var v = nanmeanpn.ndarray( 5, x, 2, 1 );
126115
// returns 1.25
127116
```
128117

@@ -136,6 +125,7 @@ var v = nanmeanpn.ndarray( N, x, 2, 1 );
136125

137126
- If `N <= 0`, both functions return `NaN`.
138127
- If every indexed element is `NaN`, both functions return `NaN`.
128+
- 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]).
139129
- Depending on the environment, the typed versions ([`dnanmeanpn`][@stdlib/stats/strided/dnanmeanpn], [`snanmeanpn`][@stdlib/stats/strided/snanmeanpn], etc.) are likely to be significantly more performant.
140130

141131
</section>
@@ -149,22 +139,19 @@ var v = nanmeanpn.ndarray( N, x, 2, 1 );
149139
<!-- eslint no-undef: "error" -->
150140

151141
```javascript
152-
var randu = require( '@stdlib/random/base/randu' );
153-
var round = require( '@stdlib/math/base/special/round' );
154-
var Float64Array = require( '@stdlib/array/float64' );
142+
var uniform = require( '@stdlib/random/base/uniform' );
143+
var filledarrayBy = require( '@stdlib/array/filled-by' );
144+
var bernoulli = require( '@stdlib/random/base/bernoulli' );
155145
var nanmeanpn = require( '@stdlib/stats/base/nanmeanpn' );
156146

157-
var x;
158-
var i;
159-
160-
x = new Float64Array( 10 );
161-
for ( i = 0; i < x.length; i++ ) {
162-
if ( randu() < 0.2 ) {
163-
x[ i ] = NaN;
164-
} else {
165-
x[ i ] = round( (randu()*100.0) - 50.0 );
147+
function rand() {
148+
if ( bernoulli( 0.8 ) < 1 ) {
149+
return NaN;
166150
}
151+
return uniform( -50.0, 50.0 );
167152
}
153+
154+
var x = filledarrayBy( 10, 'float64', rand );
168155
console.log( x );
169156

170157
var v = nanmeanpn( x.length, x, 1 );
@@ -215,6 +202,8 @@ console.log( v );
215202

216203
[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
217204

205+
[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
206+
218207
[@neely:1966a]: https://doi.org/10.1145/365719.365958
219208

220209
[@schubert:2018a]: https://doi.org/10.1145/3221269.3223036

‎lib/node_modules/@stdlib/stats/base/nanmeanpn/benchmark/benchmark.js

Lines changed: 18 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -21,15 +21,30 @@
2121
// MODULES //
2222

2323
var bench = require( '@stdlib/bench' );
24-
var randu = require( '@stdlib/random/base/randu' );
24+
var uniform = require( '@stdlib/random/base/uniform' );
25+
var bernoulli = require( '@stdlib/random/base/bernoulli' );
26+
var filledarrayBy = require( '@stdlib/array/filled-by' );
2527
var isnan = require( '@stdlib/math/base/assert/is-nan' );
2628
var pow = require( '@stdlib/math/base/special/pow' );
2729
var pkg = require( './../package.json' ).name;
28-
var nanmeanpn = require( './../lib/nanmeanpn.js' );
30+
var nanmeanpn = require( './../lib/main.js' );
2931

3032

3133
// FUNCTIONS //
3234

35+
/**
36+
* Returns a random number.
37+
*
38+
* @private
39+
* @returns {number} random number
40+
*/
41+
function rand() {
42+
if ( bernoulli( 0.8 ) < 1 ) {
43+
return NaN;
44+
}
45+
return uniform( -10.0, 10.0 );
46+
}
47+
3348
/**
3449
* Creates a benchmark function.
3550
*
@@ -38,17 +53,7 @@ var nanmeanpn = require( './../lib/nanmeanpn.js' );
3853
* @returns {Function} benchmark function
3954
*/
4055
function createBenchmark( len ) {
41-
var x;
42-
var i;
43-
44-
x = [];
45-
for ( i = 0; i < len; i++ ) {
46-
if ( randu() < 0.2 ) {
47-
x.push( NaN );
48-
} else {
49-
x.push( ( randu()*20.0 ) - 10.0 );
50-
}
51-
}
56+
var x = filledarrayBy( len, 'generic', rand );
5257
return benchmark;
5358

5459
function benchmark( b ) {

‎lib/node_modules/@stdlib/stats/base/nanmeanpn/benchmark/benchmark.ndarray.js

Lines changed: 17 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,9 @@
2121
// MODULES //
2222

2323
var bench = require( '@stdlib/bench' );
24-
var randu = require( '@stdlib/random/base/randu' );
24+
var uniform = require( '@stdlib/random/base/uniform' );
25+
var bernoulli = require( '@stdlib/random/base/bernoulli' );
26+
var filledarrayBy = require( '@stdlib/array/filled-by' );
2527
var isnan = require( '@stdlib/math/base/assert/is-nan' );
2628
var pow = require( '@stdlib/math/base/special/pow' );
2729
var pkg = require( './../package.json' ).name;
@@ -30,6 +32,19 @@ var nanmeanpn = require( './../lib/ndarray.js' );
3032

3133
// FUNCTIONS //
3234

35+
/**
36+
* Returns a random number.
37+
*
38+
* @private
39+
* @returns {number} random number
40+
*/
41+
function rand() {
42+
if ( bernoulli( 0.8 ) < 1 ) {
43+
return NaN;
44+
}
45+
return uniform( -10.0, 10.0 );
46+
}
47+
3348
/**
3449
* Creates a benchmark function.
3550
*
@@ -38,17 +53,7 @@ var nanmeanpn = require( './../lib/ndarray.js' );
3853
* @returns {Function} benchmark function
3954
*/
4055
function createBenchmark( len ) {
41-
var x;
42-
var i;
43-
44-
x = [];
45-
for ( i = 0; i < len; i++ ) {
46-
if ( randu() < 0.2 ) {
47-
x.push( NaN );
48-
} else {
49-
x.push( ( randu()*20.0 ) - 10.0 );
50-
}
51-
}
56+
var x = filledarrayBy( len, 'generic', rand );
5257
return benchmark;
5358

5459
function benchmark( b ) {

‎lib/node_modules/@stdlib/stats/base/nanmeanpn/docs/repl.txt

Lines changed: 16 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11

2-
{{alias}}( N, x, stride )
2+
{{alias}}( N, x, strideX )
33
Computes the arithmetic mean of a strided array, ignoring `NaN` values and
44
using a two-pass error correction algorithm.
55

6-
The `N` and `stride` parameters determine which elements in `x` are accessed
7-
at runtime.
6+
The `N` and stride parameters determine which elements in the strided array
7+
are accessed at runtime.
88

99
Indexing is relative to the first index. To introduce an offset, use a typed
1010
array view.
@@ -21,8 +21,8 @@
2121
x: Array<number>|TypedArray
2222
Input array.
2323

24-
stride: integer
25-
Index increment.
24+
strideX: integer
25+
Stride length.
2626

2727
Returns
2828
-------
@@ -36,22 +36,19 @@
3636
> {{alias}}( x.length, x, 1 )
3737
~0.3333
3838

39-
// Using `N` and `stride` parameters:
39+
// Using `N` and stride parameters:
4040
> x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ];
41-
> var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
42-
> var stride = 2;
43-
> {{alias}}( N, x, stride )
41+
> {{alias}}( 4, x, 2 )
4442
~0.3333
4543

4644
// Using view offsets:
47-
> var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );
45+
> var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );
4846
> var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
49-
> N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 );
50-
> stride = 2;
51-
> {{alias}}( N, x1, stride )
47+
> {{alias}}( 4, x1, 2 )
5248
~-0.3333
5349

54-
{{alias}}.ndarray( N, x, stride, offset )
50+
51+
{{alias}}.ndarray( N, x, strideX, offsetX )
5552
Computes the arithmetic mean of a strided array, ignoring `NaN` values and
5653
using a two-pass error correction algorithm and alternative indexing
5754
semantics.
@@ -68,10 +65,10 @@
6865
x: Array<number>|TypedArray
6966
Input array.
7067

71-
stride: integer
72-
Index increment.
68+
strideX: integer
69+
Stride length.
7370

74-
offset: integer
71+
offsetX: integer
7572
Starting index.
7673

7774
Returns
@@ -87,9 +84,8 @@
8784
~0.3333
8885

8986
// Using offset parameter:
90-
> var x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ];
91-
> var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 );
92-
> {{alias}}.ndarray( N, x, 2, 1 )
87+
> x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];
88+
> {{alias}}.ndarray( 4, x, 2, 1 )
9389
~-0.3333
9490

9591
See Also

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

Lines changed: 12 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,12 @@
2020

2121
/// <reference types="@stdlib/types"/>
2222

23-
import { NumericArray } from '@stdlib/types/array';
23+
import { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array';
24+
25+
/**
26+
* Input array.
27+
*/
28+
type InputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
2429

2530
/**
2631
* Interface describing `nanmeanpn`.
@@ -31,7 +36,7 @@ interface Routine {
3136
*
3237
* @param N - number of indexed elements
3338
* @param x - input array
34-
* @param stride - stride length
39+
* @param strideX - stride length
3540
* @returns arithmetic mean
3641
*
3742
* @example
@@ -40,15 +45,15 @@ interface Routine {
4045
* var v = nanmeanpn( x.length, x, 1 );
4146
* // returns ~0.3333
4247
*/
43-
( N: number, x: NumericArray, stride: number ): number;
48+
( N: number, x: InputArray, strideX: number ): number;
4449

4550
/**
4651
* Computes the arithmetic mean of a strided array, ignoring `NaN` values and using a two-pass error correction algorithm and alternative indexing semantics.
4752
*
4853
* @param N - number of indexed elements
4954
* @param x - input array
50-
* @param stride - stride length
51-
* @param offset - starting index
55+
* @param strideX - stride length
56+
* @param offsetX - starting index
5257
* @returns arithmetic mean
5358
*
5459
* @example
@@ -57,15 +62,15 @@ interface Routine {
5762
* var v = nanmeanpn.ndarray( x.length, x, 1, 0 );
5863
* // returns ~0.3333
5964
*/
60-
ndarray( N: number, x: NumericArray, stride: number, offset: number ): number;
65+
ndarray( N: number, x: InputArray, strideX: number, offsetX: number ): number;
6166
}
6267

6368
/**
6469
* Computes the arithmetic mean of a strided array, ignoring `NaN` values and using a two-pass error correction algorithm.
6570
*
6671
* @param N - number of indexed elements
6772
* @param x - input array
68-
* @param stride - stride length
73+
* @param strideX - stride length
6974
* @returns arithmetic mean
7075
*
7176
* @example

0 commit comments

Comments
 (0)