# randu
> Fill a strided array with [uniformly][@stdlib/random/base/randu] distributed pseudorandom numbers between `0` and `1`.
## Usage
```javascript
var randu = require( '@stdlib/random/strided/randu' );
```
#### randu( N, out, so\[, options] )
Fills a strided array with [uniformly][@stdlib/random/base/randu] distributed pseudorandom numbers between `0` and `1`.
```javascript
var Float64Array = require( '@stdlib/array/float64' );
// Create an array:
var out = new Float64Array( 10 );
// Fill the array with pseudorandom numbers:
randu( out.length, out, 1 );
```
The function has the following parameters:
- **N**: number of indexed elements.
- **out**: output array.
- **so**: index increment for `out`.
The `N` and stride parameters determine which strided array elements are accessed at runtime. For example, to access every other value in `out`,
```javascript
var out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ];
randu( 3, out, 2 );
```
Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
```javascript
var Float64Array = require( '@stdlib/array/float64' );
// Initial array:
var out0 = new Float64Array( 6 );
// Create offset views:
var out1 = new Float64Array( out0.buffer, out0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
// Fill the output array:
randu( out1.length, out1, 1 );
```
The function accepts the following `options`:
- **name**: name of a supported pseudorandom number generator (PRNG), which will serve as the underlying source of pseudorandom numbers. The following generators are supported:
- [`mt19937`][@stdlib/random/base/mt19937]: 32-bit Mersenne Twister.
- [`minstd`][@stdlib/random/base/minstd]: linear congruential pseudorandom number generator (LCG) based on Park and Miller.
- [`minstd-shuffle`][@stdlib/random/base/minstd-shuffle]: linear congruential pseudorandom number generator (LCG) whose output is shuffled.
Default: [`'mt19937'`][@stdlib/random/base/mt19937].
- **seed**: pseudorandom number generator seed. Valid seed values vary according to the underlying PRNG.
- **state**: pseudorandom number generator state. Valid state values vary according to the underlying PRNG. If provided, the function ignores the `seed` option.
- **copy**: `boolean` indicating whether to copy a provided pseudorandom number generator state. Setting this option to `false` allows sharing state between two or more pseudorandom number generators. Setting this option to `true` ensures that a returned generator has exclusive control over its internal state. Default: `true`.
By default, the underlying pseudorandom number generator is [`mt19937`][@stdlib/random/base/mt19937]. To use a different PRNG, set the `name` option.
```javascript
var Float64Array = require( '@stdlib/array/float64' );
var opts = {
'name': 'minstd-shuffle'
};
var out = new Float64Array( 10 );
randu( out.length, out, 1, opts );
```
To seed the underlying pseudorandom number generator, set the `seed` option.
```javascript
var Float64Array = require( '@stdlib/array/float64' );
var opts = {
'seed': 12345
};
var out = new Float64Array( 10 );
randu( out.length, out, 1, opts );
```
#### randu.ndarray( N, out, so, oo\[, options] )
Fills a strided array with [uniformly][@stdlib/random/base/randu] distributed pseudorandom numbers between `0` and `1` using alternative indexing semantics.
```javascript
var Float64Array = require( '@stdlib/array/float64' );
// Create an array:
var out = new Float64Array( 10 );
// Fill the array with pseudorandom numbers:
randu.ndarray( out.length, out, 1, 0 );
```
The function has the following additional parameters:
- **oo**: starting index for `out`.
While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the offset parameters support indexing semantics based on starting indices. For example, to access every other value in `out` starting from the second value,
```javascript
var out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ];
randu.ndarray( 3, out, 2, 1 );
```
The function accepts the same `options` as documented above for `randu()`.
## Notes
- If `N <= 0`, both functions leave the output array unchanged.
- Both functions support array-like objects having getter and setter accessors for array element access.
## Examples
```javascript
var zeros = require( '@stdlib/array/zeros' );
var zeroTo = require( '@stdlib/array/base/zero-to' );
var logEach = require( '@stdlib/console/log-each' );
var randu = require( '@stdlib/random/strided/randu' );
// Specify a PRNG seed:
var opts = {
'seed': 1234
};
// Create an array:
var x1 = zeros( 10, 'float64' );
// Create a list of indices:
var idx = zeroTo( x1.length );
// Fill the array with pseudorandom numbers:
randu( x1.length, x1, 1, opts );
// Create a second array:
var x2 = zeros( 10, 'generic' );
// Fill the array with the same pseudorandom numbers:
randu( x2.length, x2, 1, opts );
// Print the array contents:
logEach( 'x1[%d] = %.2f; x2[%d] = %.2f', idx, x1, idx, x2 );
```
[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
[@stdlib/random/base/randu]: https://github.com/stdlib-js/random/tree/main/base/randu
[@stdlib/random/base/mt19937]: https://github.com/stdlib-js/random/tree/main/base/mt19937
[@stdlib/random/base/minstd]: https://github.com/stdlib-js/random/tree/main/base/minstd
[@stdlib/random/base/minstd-shuffle]: https://github.com/stdlib-js/random/tree/main/base/minstd-shuffle
[@stdlib/random/array/randu]: https://github.com/stdlib-js/random/tree/main/array/randu
[@stdlib/random/strided/uniform]: https://github.com/stdlib-js/random/tree/main/strided/uniform