diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
new file mode 100644
index 000000000000..4f53322e0947
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
@@ -0,0 +1,261 @@
+
+
+# dlaruv
+
+> Return a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+
+
+
+## Usage
+
+```javascript
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+```
+
+#### dlaruv( seed, N, x )
+
+Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+var x = new Float64Array( 3 );
+
+dlaruv( seed, 3, x );
+// x => [ ~0.1319, ~0.2338, ~0.3216 ]
+```
+
+The function has the following parameters:
+
+- **seed**: [`Int32Array`][@stdlib/array/int32] seed array of four integers. Each element must be between `0` and `4095`, and `seed[3]` must be odd. On exit, the seed is updated.
+- **N**: number of random numbers to generate. Must be at most `128`.
+- **x**: output [`Float64Array`][@stdlib/array/float64].
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+// Initial arrays...
+var seed0 = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var x0 = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+
+// Create offset views...
+var seed1 = new Int32Array( seed0.buffer, seed0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dlaruv( seed1, 3, x1 );
+// x0 => [ 0.0, ~0.1319, ~0.2338, ~0.3216 ]
+```
+
+#### dlaruv.ndarray( N, seed, strideS, offsetS, x, strideX, offsetX )
+
+Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution using alternative indexing semantics.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+var x = new Float64Array( 3 );
+
+dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+// x => [ ~0.1319, ~0.2338, ~0.3216 ]
+```
+
+The function has the following additional parameters:
+
+- **strideS**: stride length for `seed`.
+- **offsetS**: starting index for `seed`.
+- **strideX**: stride length 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 parameters support indexing semantics based on starting indices. For example,
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var seed = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var x = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+dlaruv.ndarray( 3, seed, 1, 1, x, 1, 2 );
+// x => [ 0.0, 0.0, ~0.1319, ~0.2338, ~0.3216 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- `seed` is updated in-place and should be reused across invocations in order to generate a continuous stream of random numbers.
+- At most `128` random numbers are generated per invocation. If `N > 128`, only the first `128` indexed elements of `x` are updated.
+- If `N <= 0`, the functions return `x` unchanged and do not update `seed`.
+- Generated values are always on the open interval `(0,1)`, as the largest representable output is `1 - 2^-48`.
+- `dlaruv()` corresponds to the [LAPACK][LAPACK] function [`dlaruv`][lapack-dlaruv].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+
+var seed = new Int32Array( [ 1, 23, 456, 3795 ] );
+var x = new Float64Array( 10 );
+
+dlaruv( seed, x.length, x );
+
+console.log( x );
+console.log( seed );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+* * *
+
+
+
+## References
+
+- Fishman, George S. 1990. "Multiplicative Congruential Random Number Generators with Modulus 2^β: An Exhaustive Analysis for β = 32 and a Partial Analysis for β = 48." _Mathematics of Computation_ 54 (189). American Mathematical Society: 331–44. doi:[10.2307/2008698][@fishman1990a].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlaruv]: https://netlib.org/lapack/explore-html/d9/d0f/group__laruv.html
+
+[@stdlib/array/int32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/int32
+
+[@stdlib/array/float64]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float64
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+[@fishman1990a]: https://doi.org/10.2307/2008698
+
+
+
+
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
new file mode 100644
index 000000000000..5c296a57afc8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
@@ -0,0 +1,97 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlaruv = require( './../lib/dlaruv.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var seed = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+ var x = new Float64Array( len );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlaruv( seed, len, x );
+ if ( isnan( x[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( x[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var max;
+ var min;
+ var f;
+ var i;
+
+ min = 0; // 2^min
+ max = 7; // 2^max (capped at 128)
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 2, i );
+ f = createBenchmark( len );
+ bench( format( '%s:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..99756bf8b4a2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
@@ -0,0 +1,97 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlaruv = require( './../lib/ndarray.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var seed = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+ var x = new Float64Array( len );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlaruv( len, seed, 1, 0, x, 1, 0 );
+ if ( isnan( x[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( x[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var max;
+ var min;
+ var f;
+ var i;
+
+ min = 0; // 2^min
+ max = 7; // 2^max (capped at 128)
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 2, i );
+ f = createBenchmark( len );
+ bench( format( '%s:ndarray:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
new file mode 100644
index 000000000000..113b863e12fa
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
@@ -0,0 +1,105 @@
+
+{{alias}}( seed, N, x )
+ Returns a vector of `N` random real numbers drawn from a uniform (0,1)
+ distribution.
+
+ Indexing is relative to the first index. To introduce an offset, use typed
+ array views.
+
+ The function mutates the input seed array `seed`.
+
+ At most `128` random numbers are generated per invocation. If `N` is greater
+ than `128`, only the first `128` elements of `x` are updated.
+
+ If `N` is less than or equal to `0`, the function returns `x` unchanged and
+ does not update `seed`.
+
+ Parameters
+ ----------
+ seed: Int32Array
+ Seed array of four integers. Each element must be between `0` and
+ `4095`, and `seed[3]` must be odd.
+
+ N: integer
+ Number of random numbers to generate (N <= 128).
+
+ x: Float64Array
+ Output array.
+
+ Returns
+ -------
+ x: Float64Array
+ Output array.
+
+ Examples
+ --------
+ > var seed = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3 ] );
+ > var x = new {{alias:@stdlib/array/float64}}( 3 );
+ > {{alias}}( seed, 3, x )
+ [ ~0.1319, ~0.2338, ~0.3216 ]
+ > seed
+ [ 1317, 1915, 1613, 2663 ]
+
+ // Using typed array views:
+ > var seed0 = new {{alias:@stdlib/array/int32}}( [ 0, 0, 1, 2, 3 ] );
+ > var x0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+ > var seed1 = new {{alias:@stdlib/array/int32}}( seed0.buffer, seed0.BYTES_PER_ELEMENT*1 );
+ > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+ > {{alias}}( seed1, 3, x1 )
+ [ ~0.1319, ~0.2338, ~0.3216 ]
+
+
+{{alias}}.ndarray( N, seed, strideS, offsetS, x, strideX, offsetX )
+ Returns a vector of `N` random real numbers drawn from a uniform (0,1)
+ distribution using alternative indexing semantics.
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameters support indexing semantics based on starting
+ indices.
+
+ The function mutates the input seed array `seed`.
+
+ At most `128` random numbers are generated per invocation. If `N` is greater
+ than `128`, only the first `128` indexed elements of `x` are updated.
+
+ If `N` is less than or equal to `0`, the function returns `x` unchanged and
+ does not update `seed`.
+
+ Parameters
+ ----------
+ N: integer
+ Number of random numbers to generate (N <= 128).
+
+ seed: Int32Array
+ Seed array of four integers. Each element must be between `0` and
+ `4095`, and `seed[3]` must be odd.
+
+ strideS: integer
+ Stride length for `seed`.
+
+ offsetS: integer
+ Starting index for `seed`.
+
+ x: Float64Array
+ Output array.
+
+ strideX: integer
+ Stride length for `x`.
+
+ offsetX: integer
+ Starting index for `x`.
+
+ Returns
+ -------
+ x: Float64Array
+ Output array.
+
+ Examples
+ --------
+ > var seed = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3 ] );
+ > var x = new {{alias:@stdlib/array/float64}}( 3 );
+ > {{alias}}.ndarray( 3, seed, 1, 0, x, 1, 0 )
+ [ ~0.1319, ~0.2338, ~0.3216 ]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
new file mode 100644
index 000000000000..fd4974556c88
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
@@ -0,0 +1,115 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Interface describing `dlaruv`.
+*/
+interface Routine {
+ /**
+ * Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+ *
+ * ## Notes
+ *
+ * - `seed` should have four indexed elements, each of which must be on the interval `[0, 4095]`, with `seed[3]` being odd. On exit, `seed` is updated.
+ * - At most `128` random numbers are generated per invocation. If `N > 128`, only the first `128` indexed elements of `x` are updated.
+ * - If `N <= 0`, the function returns `x` unchanged and does not update `seed`.
+ *
+ * @param seed - seed array of four integers
+ * @param N - number of random numbers to generate
+ * @param x - output array
+ * @returns output array
+ *
+ * @example
+ * var Int32Array = require( '@stdlib/array/int32' );
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ * var x = new Float64Array( 3 );
+ *
+ * dlaruv( seed, 3, x );
+ * // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+ */
+ ( seed: Int32Array, N: number, x: Float64Array ): Float64Array;
+
+ /**
+ * Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution using alternative indexing semantics.
+ *
+ * ## Notes
+ *
+ * - `seed` should have four indexed elements, each of which must be on the interval `[0, 4095]`, with the fourth indexed element being odd. On exit, `seed` is updated.
+ * - At most `128` random numbers are generated per invocation. If `N > 128`, only the first `128` indexed elements of `x` are updated.
+ * - If `N <= 0`, the function returns `x` unchanged and does not update `seed`.
+ *
+ * @param N - number of random numbers to generate
+ * @param seed - seed array of four integers
+ * @param strideS - stride length for `seed`
+ * @param offsetS - starting index for `seed`
+ * @param x - output array
+ * @param strideX - stride length for `x`
+ * @param offsetX - starting index for `x`
+ * @returns output array
+ *
+ * @example
+ * var Int32Array = require( '@stdlib/array/int32' );
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ * var x = new Float64Array( 3 );
+ *
+ * dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+ * // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+ */
+ ndarray( N: number, seed: Int32Array, strideS: number, offsetS: number, x: Float64Array, strideX: number, offsetX: number ): Float64Array;
+}
+
+/**
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+*
+* @param seed - seed array of four integers
+* @param N - number of random numbers to generate
+* @param x - output array
+* @returns output array
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv( seed, 3, x );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*/
+declare var dlaruv: Routine;
+
+
+// EXPORTS //
+
+export = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
new file mode 100644
index 000000000000..e0ff541e0aad
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
@@ -0,0 +1,214 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+import dlaruv = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Float64Array...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv( seed, 3, x ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an Int32Array...
+{
+ const x = new Float64Array( 3 );
+
+ dlaruv( '5', 3, x ); // $ExpectError
+ dlaruv( 5, 3, x ); // $ExpectError
+ dlaruv( true, 3, x ); // $ExpectError
+ dlaruv( false, 3, x ); // $ExpectError
+ dlaruv( null, 3, x ); // $ExpectError
+ dlaruv( void 0, 3, x ); // $ExpectError
+ dlaruv( [], 3, x ); // $ExpectError
+ dlaruv( {}, 3, x ); // $ExpectError
+ dlaruv( ( x: number ): number => x, 3, x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv( seed, '5', x ); // $ExpectError
+ dlaruv( seed, true, x ); // $ExpectError
+ dlaruv( seed, false, x ); // $ExpectError
+ dlaruv( seed, null, x ); // $ExpectError
+ dlaruv( seed, void 0, x ); // $ExpectError
+ dlaruv( seed, [], x ); // $ExpectError
+ dlaruv( seed, {}, x ); // $ExpectError
+ dlaruv( seed, ( x: number ): number => x, x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+
+ dlaruv( seed, 3, '5' ); // $ExpectError
+ dlaruv( seed, 3, 5 ); // $ExpectError
+ dlaruv( seed, 3, true ); // $ExpectError
+ dlaruv( seed, 3, false ); // $ExpectError
+ dlaruv( seed, 3, null ); // $ExpectError
+ dlaruv( seed, 3, void 0 ); // $ExpectError
+ dlaruv( seed, 3, [] ); // $ExpectError
+ dlaruv( seed, 3, {} ); // $ExpectError
+ dlaruv( seed, 3, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv(); // $ExpectError
+ dlaruv( seed ); // $ExpectError
+ dlaruv( seed, 3 ); // $ExpectError
+ dlaruv( seed, 3, x, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float64Array...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( '5', seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( true, seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( false, seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( null, seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( void 0, seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( [], seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( {}, seed, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( ( x: number ): number => x, seed, 1, 0, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not an Int32Array...
+{
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, '5', 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, 5, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, true, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, false, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, null, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, void 0, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, [], 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, {}, 1, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ( x: number ): number => x, 1, 0, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, seed, '5', 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, true, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, false, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, null, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, void 0, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, [], 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, {}, 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, ( x: number ): number => x, 0, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, seed, 1, '5', x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, true, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, false, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, null, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, void 0, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, [], x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, {}, x, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, ( x: number ): number => x, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Float64Array...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+
+ dlaruv.ndarray( 3, seed, 1, 0, '5', 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, 5, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, true, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, false, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, null, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, void 0, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, [], 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, {}, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, seed, 1, 0, x, '5', 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, true, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, false, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, null, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, void 0, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, [], 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, {}, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, '5' ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, true ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, false ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, null ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, void 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, [] ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, {} ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ const x = new Float64Array( 3 );
+
+ dlaruv.ndarray(); // $ExpectError
+ dlaruv.ndarray( 3 ); // $ExpectError
+ dlaruv.ndarray( 3, seed ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1 ); // $ExpectError
+ dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
new file mode 100644
index 000000000000..19c141d67f10
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
@@ -0,0 +1,31 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlaruv = require( './../lib' );
+
+var seed = new Int32Array( [ 1, 23, 456, 3795 ] );
+var x = new Float64Array( 10 );
+
+dlaruv( seed, x.length, x );
+
+console.log( x );
+console.log( seed );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
new file mode 100644
index 000000000000..1114f7f5dae1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
@@ -0,0 +1,59 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+*
+* ## Notes
+*
+* - `seed` should have four indexed elements, each of which must be on the interval `[0, 4095]`, with `seed[3]` being odd. On exit, `seed` is updated.
+* - At most `128` random numbers are generated per invocation. If `N > 128`, only the first `128` indexed elements of `x` are updated.
+* - If `N <= 0`, the function returns `x` unchanged and does not update `seed`.
+*
+* @param {Int32Array} seed - seed array of four integers
+* @param {NonNegativeInteger} N - number of random numbers to generate
+* @param {Float64Array} x - output array
+* @returns {Float64Array} output array
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv( seed, 3, x );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*/
+function dlaruv( seed, N, x ) {
+ return ndarray( N, seed, 1, 0, x, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
new file mode 100644
index 000000000000..7b558e40b0a8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
@@ -0,0 +1,72 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+/**
+* LAPACK routine to return a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
+*
+* @module @stdlib/lapack/base/dlaruv
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv( seed, 3, x );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var dlaruv;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlaruv = main;
+} else {
+ dlaruv = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
+
+// exports: { "ndarray": "dlaruv.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js
new file mode 100644
index 000000000000..1494a1e52b11
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dlaruv = require( './dlaruv.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlaruv, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
new file mode 100644
index 000000000000..9b8e30491983
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
@@ -0,0 +1,272 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var floor = require( '@stdlib/math/base/special/floor' );
+var min = require( '@stdlib/math/base/special/fast/min' );
+
+
+// VARIABLES //
+
+var LV = 128;
+var IPW2 = 4096;
+var R = 1.0 / IPW2;
+
+/*
+* MM table: 128 x 4 (row-major).
+*
+* ## Notes
+*
+* - Each row i contains the multiplier for the (i+1)-th power of the base multiplier modulo 2^48.
+*
+* ```text
+* MM[i][j] = MM_TABLE[ i ][ j ] for i = 0..127, j = 0..3
+* ```
+*
+* - Transcribed directly from the LAPACK reference Fortran source (`dlaruv.f`).
+*/
+var MM_TABLE = [
+ [ 494, 322, 2508, 2549 ],
+ [ 2637, 789, 3754, 1145 ],
+ [ 255, 1440, 1766, 2253 ],
+ [ 2008, 752, 3572, 305 ],
+ [ 1253, 2859, 2893, 3301 ],
+ [ 3344, 123, 307, 1065 ],
+ [ 4084, 1848, 1297, 3133 ],
+ [ 1739, 643, 3966, 2913 ],
+ [ 3143, 2405, 758, 3285 ],
+ [ 3468, 2638, 2598, 1241 ],
+ [ 688, 2344, 3406, 1197 ],
+ [ 1657, 46, 2922, 3729 ],
+ [ 1238, 3814, 1038, 2501 ],
+ [ 3166, 913, 2934, 1673 ],
+ [ 1292, 3649, 2091, 541 ],
+ [ 3422, 339, 2451, 2753 ],
+ [ 1270, 3808, 1580, 949 ],
+ [ 2016, 822, 1958, 2361 ],
+ [ 154, 2832, 2055, 1165 ],
+ [ 2862, 3078, 1507, 4081 ],
+ [ 697, 3633, 1078, 2725 ],
+ [ 1706, 2970, 3273, 3305 ],
+ [ 491, 637, 17, 3069 ],
+ [ 931, 2249, 854, 3617 ],
+ [ 1444, 2081, 2916, 3733 ],
+ [ 444, 4019, 3971, 409 ],
+ [ 3577, 1478, 2889, 2157 ],
+ [ 3944, 242, 3831, 1361 ],
+ [ 2184, 481, 2621, 3973 ],
+ [ 1661, 2075, 1541, 1865 ],
+ [ 3482, 4058, 893, 2525 ],
+ [ 657, 622, 736, 1409 ],
+ [ 3023, 3376, 3992, 3445 ],
+ [ 3618, 812, 787, 3577 ],
+ [ 1267, 234, 2125, 77 ],
+ [ 1828, 641, 2364, 3761 ],
+ [ 164, 4005, 2460, 2149 ],
+ [ 3798, 1122, 257, 1449 ],
+ [ 3087, 3135, 1574, 3005 ],
+ [ 2400, 2640, 3912, 225 ],
+ [ 2870, 2302, 1216, 85 ],
+ [ 3876, 40, 3248, 3673 ],
+ [ 1905, 1832, 3401, 3117 ],
+ [ 1593, 2247, 2124, 3089 ],
+ [ 1797, 2034, 2762, 1349 ],
+ [ 1234, 2637, 149, 2057 ],
+ [ 3460, 1287, 2245, 413 ],
+ [ 328, 1691, 166, 65 ],
+ [ 2861, 496, 466, 1845 ],
+ [ 1950, 1597, 4018, 697 ],
+ [ 617, 2394, 1399, 3085 ],
+ [ 2070, 2584, 190, 3441 ],
+ [ 3331, 1843, 2879, 1573 ],
+ [ 769, 336, 153, 3689 ],
+ [ 1558, 1472, 2320, 2941 ],
+ [ 2412, 2407, 18, 929 ],
+ [ 2800, 433, 712, 533 ],
+ [ 189, 2096, 2159, 2841 ],
+ [ 287, 1761, 2318, 4077 ],
+ [ 2045, 2810, 2091, 721 ],
+ [ 1227, 566, 3443, 2821 ],
+ [ 2838, 442, 1510, 2249 ],
+ [ 209, 41, 449, 2397 ],
+ [ 2770, 1238, 1956, 2817 ],
+ [ 3654, 1086, 2201, 245 ],
+ [ 3993, 603, 3137, 1913 ],
+ [ 192, 840, 3399, 1997 ],
+ [ 2253, 3168, 1321, 3121 ],
+ [ 3491, 1499, 2271, 997 ],
+ [ 2889, 1084, 3667, 1833 ],
+ [ 2857, 3438, 2703, 2877 ],
+ [ 2094, 2408, 629, 1633 ],
+ [ 1818, 1589, 2365, 981 ],
+ [ 688, 2391, 2431, 2009 ],
+ [ 1407, 288, 1113, 941 ],
+ [ 634, 26, 3922, 2449 ],
+ [ 3231, 512, 2554, 197 ],
+ [ 815, 1456, 184, 2441 ],
+ [ 3524, 171, 2099, 285 ],
+ [ 1914, 1677, 3228, 1473 ],
+ [ 516, 2657, 4012, 2741 ],
+ [ 164, 2270, 1921, 3129 ],
+ [ 303, 2587, 3452, 909 ],
+ [ 2144, 2961, 3901, 2801 ],
+ [ 3480, 1970, 572, 421 ],
+ [ 119, 1817, 3309, 4073 ],
+ [ 3357, 676, 3171, 2813 ],
+ [ 837, 1410, 817, 2337 ],
+ [ 2826, 3723, 3039, 1429 ],
+ [ 2332, 2803, 1696, 1177 ],
+ [ 2089, 3185, 1256, 1901 ],
+ [ 3780, 184, 3715, 81 ],
+ [ 1700, 663, 2077, 1669 ],
+ [ 3712, 499, 3019, 2633 ],
+ [ 150, 3784, 1497, 2269 ],
+ [ 2000, 1631, 1101, 129 ],
+ [ 3375, 1925, 717, 1141 ],
+ [ 1621, 3912, 51, 249 ],
+ [ 3090, 1398, 981, 3917 ],
+ [ 3765, 1349, 1978, 2481 ],
+ [ 1149, 1441, 1813, 3941 ],
+ [ 3146, 2224, 3881, 2217 ],
+ [ 33, 2411, 76, 2749 ],
+ [ 3082, 1907, 3846, 3041 ],
+ [ 2741, 3192, 3694, 1877 ],
+ [ 359, 2786, 1682, 345 ],
+ [ 3316, 382, 124, 2861 ],
+ [ 1749, 37, 1660, 1809 ],
+ [ 185, 759, 3997, 3141 ],
+ [ 2784, 2948, 479, 2825 ],
+ [ 2202, 1862, 1141, 157 ],
+ [ 2199, 3802, 886, 2881 ],
+ [ 1364, 2423, 3514, 3637 ],
+ [ 1244, 2051, 1301, 1465 ],
+ [ 2020, 2295, 3604, 2829 ],
+ [ 3160, 1332, 1888, 2161 ],
+ [ 2785, 1832, 1836, 3365 ],
+ [ 2772, 2405, 1990, 361 ],
+ [ 1217, 3638, 2058, 2685 ],
+ [ 1822, 3661, 692, 3745 ],
+ [ 1245, 327, 1194, 2325 ],
+ [ 2252, 3660, 20, 3609 ],
+ [ 3904, 716, 3285, 3821 ],
+ [ 2774, 1842, 2046, 3537 ],
+ [ 997, 3987, 2107, 517 ],
+ [ 2573, 1368, 3508, 3017 ],
+ [ 1148, 1848, 3525, 2141 ],
+ [ 545, 2366, 3801, 1537 ]
+];
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution using alternative indexing semantics.
+*
+* ## Notes
+*
+* - `seed` should have four indexed elements, each of which must be on the interval `[0, 4095]`, with the fourth indexed element being odd. On exit, `seed` is updated.
+* - At most `128` random numbers are generated per invocation. If `N > 128`, only the first `128` indexed elements of `x` are updated.
+* - If `N <= 0`, the function returns `x` unchanged and does not update `seed`.
+*
+* @param {NonNegativeInteger} N - number of random numbers to generate
+* @param {Int32Array} seed - seed array of four integers
+* @param {integer} strideS - stride length for `seed`
+* @param {NonNegativeInteger} offsetS - starting index for `seed`
+* @param {Float64Array} x - output array
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @returns {Float64Array} output array
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
+*
+* dlaruv( 3, seed, 1, 0, x, 1, 0 );
+* // x => [ ~0.1319, ~0.2338, ~0.3216 ]
+*/
+function dlaruv( N, seed, strideS, offsetS, x, strideX, offsetX ) {
+ var row;
+ var it1;
+ var it2;
+ var it3;
+ var it4;
+ var i1;
+ var i2;
+ var i3;
+ var i4;
+ var ox;
+ var i;
+
+ if ( N <= 0 ) {
+ return x;
+ }
+
+ // Copy seed values into local variables:
+ i1 = seed[ offsetS ];
+ i2 = seed[ offsetS + strideS ];
+ i3 = seed[ offsetS + ( 2 * strideS ) ];
+ i4 = seed[ offsetS + ( 3 * strideS ) ];
+
+ /*
+ * After computing a value, the reference LAPACK implementation guards against that value having rounded to exactly `1.0` by advancing the seed and regenerating the value. The guard is omitted here, as it is only reachable when generating single-precision values (e.g., as in `slaruv`).
+ *
+ * Each of `it1`, `it2`, `it3`, and `it4` is on the interval `[0, 4095]`, and, hence, a generated value is exactly `k / 2^48` for some integer `k` on the interval `[0, 2^48-1]`. As `2^48 < 2^53`, every such value is exactly representable as a double-precision floating-point number, making the conversion below exact and bounding the largest possible value by `1 - 2^-48`.
+ */
+ ox = offsetX;
+ for ( i = 0; i < min( N, LV ); i++ ) {
+ row = MM_TABLE[ i ];
+
+ // Multiply the seed by the i-th power of the multiplier modulo 2^48:
+ it4 = i4 * row[ 3 ];
+ it3 = floor( it4 / IPW2 );
+ it4 -= IPW2 * it3;
+ it3 += ( i3 * row[ 3 ] ) + ( i4 * row[ 2 ] );
+ it2 = floor( it3 / IPW2 );
+ it3 -= IPW2 * it2;
+ it2 += ( i2 * row[ 3 ] ) + ( i3 * row[ 2 ] ) + ( i4 * row[ 1 ] );
+ it1 = floor( it2 / IPW2 );
+ it2 -= IPW2 * it1;
+ it1 += ( i1 * row[ 3 ] ) + ( i2 * row[ 2 ] ) + ( i3 * row[ 1 ] ) + ( i4 * row[ 0 ] );
+ it1 %= IPW2;
+
+ // Convert 48-bit integer to a real number in the interval (0,1):
+ x[ ox ] = ( R * ( it1 + ( R * ( it2 + ( R * ( it3 + ( R * it4 ) ) ) ) ) ) );
+ ox += strideX;
+ }
+
+ // Update seed values:
+ seed[ offsetS ] = it1;
+ seed[ offsetS + strideS ] = it2;
+ seed[ offsetS + ( 2 * strideS ) ] = it3;
+ seed[ offsetS + ( 3 * strideS ) ] = it4;
+
+ return x;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json
new file mode 100644
index 000000000000..c31eac361ade
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json
@@ -0,0 +1,70 @@
+{
+ "name": "@stdlib/lapack/base/dlaruv",
+ "version": "0.0.0",
+ "description": "Return a vector of `N` random real numbers drawn from a uniform (0,1) distribution.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "stdmath",
+ "mathematics",
+ "math",
+ "lapack",
+ "dlaruv",
+ "random",
+ "uniform",
+ "prng",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json
new file mode 100644
index 000000000000..b55a87d9349b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json
@@ -0,0 +1,71 @@
+{
+ "N": 10,
+ "ISEED": [
+ 100,
+ 9999,
+ 200,
+ 9999,
+ 300,
+ 9999,
+ 401,
+ 9999
+ ],
+ "strideISEED": 2,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 9999,
+ 0.3059602026783388,
+ 9999,
+ 0.7615758157127068,
+ 9999,
+ 0.6079652337045935,
+ 9999,
+ 0.0786368892901983,
+ 9999,
+ 0.4000379493120114,
+ 9999,
+ 0.10082534071584703,
+ 9999,
+ 0.23506144863762657,
+ 9999,
+ 0.17051886842240904,
+ 9999,
+ 0.009087995793297665,
+ 9999
+ ],
+ "ISEED_out": [
+ 37,
+ 9999,
+ 919,
+ 9999,
+ 1099,
+ 9999,
+ 2025,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json
new file mode 100644
index 000000000000..673094a8ecf2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json
@@ -0,0 +1,51 @@
+{
+ "N": 5,
+ "ISEED": [
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 2,
+ 9999,
+ 3,
+ 9999
+ ],
+ "strideISEED": 2,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 9999,
+ 0.23381133728018355,
+ 9999,
+ 0.321647369501445,
+ 9999,
+ 0.7105395653957878,
+ 9999,
+ 0.021072610098311628,
+ 9999
+ ],
+ "ISEED_out": [
+ 86,
+ 9999,
+ 1283,
+ 9999,
+ 2995,
+ 9999,
+ 1711,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json
new file mode 100644
index 000000000000..49bfa7b661ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json
@@ -0,0 +1,43 @@
+{
+ "N": 10,
+ "ISEED": [
+ 100,
+ 200,
+ 300,
+ 401
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 0.3059602026783388,
+ 0.7615758157127068,
+ 0.6079652337045935,
+ 0.0786368892901983,
+ 0.4000379493120114,
+ 0.10082534071584703,
+ 0.23506144863762657,
+ 0.17051886842240904,
+ 0.009087995793297665
+ ],
+ "ISEED_out": [
+ 37,
+ 919,
+ 1099,
+ 2025
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json
new file mode 100644
index 000000000000..d8c21f2dc7fd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json
@@ -0,0 +1,71 @@
+{
+ "N": 10,
+ "ISEED": [
+ 401,
+ 9999,
+ 300,
+ 9999,
+ 200,
+ 9999,
+ 100,
+ 9999
+ ],
+ "strideISEED": -2,
+ "offsetISEED": 6,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 9999,
+ 0.3059602026783388,
+ 9999,
+ 0.7615758157127068,
+ 9999,
+ 0.6079652337045935,
+ 9999,
+ 0.0786368892901983,
+ 9999,
+ 0.4000379493120114,
+ 9999,
+ 0.10082534071584703,
+ 9999,
+ 0.23506144863762657,
+ 9999,
+ 0.17051886842240904,
+ 9999,
+ 0.009087995793297665,
+ 9999
+ ],
+ "ISEED_out": [
+ 2025,
+ 9999,
+ 1099,
+ 9999,
+ 919,
+ 9999,
+ 37,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json
new file mode 100644
index 000000000000..d0658f040d6d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json
@@ -0,0 +1,51 @@
+{
+ "N": 5,
+ "ISEED": [
+ 3,
+ 9999,
+ 2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideISEED": -2,
+ "offsetISEED": 6,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 9999,
+ 0.23381133728018355,
+ 9999,
+ 0.321647369501445,
+ 9999,
+ 0.7105395653957878,
+ 9999,
+ 0.021072610098311628,
+ 9999
+ ],
+ "ISEED_out": [
+ 1711,
+ 9999,
+ 2995,
+ 9999,
+ 1283,
+ 9999,
+ 86,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json
new file mode 100644
index 000000000000..4b7de9bc1e25
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json
@@ -0,0 +1,43 @@
+{
+ "N": 10,
+ "ISEED": [
+ 401,
+ 300,
+ 200,
+ 100
+ ],
+ "strideISEED": -1,
+ "offsetISEED": 3,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": -1,
+ "offsetX": 9,
+ "X_out": [
+ 0.009087995793297665,
+ 0.17051886842240904,
+ 0.23506144863762657,
+ 0.10082534071584703,
+ 0.4000379493120114,
+ 0.0786368892901983,
+ 0.6079652337045935,
+ 0.7615758157127068,
+ 0.3059602026783388,
+ 0.7221151762867244
+ ],
+ "ISEED_out": [
+ 2025,
+ 1099,
+ 919,
+ 37
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json
new file mode 100644
index 000000000000..ccd9b0610330
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json
@@ -0,0 +1,33 @@
+{
+ "N": 5,
+ "ISEED": [
+ 3,
+ 2,
+ 1,
+ 0
+ ],
+ "strideISEED": -1,
+ "offsetISEED": 3,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": -1,
+ "offsetX": 4,
+ "X_out": [
+ 0.021072610098311628,
+ 0.7105395653957878,
+ 0.321647369501445,
+ 0.23381133728018355,
+ 0.13185632717602047
+ ],
+ "ISEED_out": [
+ 1711,
+ 2995,
+ 1283,
+ 86
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json
new file mode 100644
index 000000000000..f3b8406c66a6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json
@@ -0,0 +1,47 @@
+{
+ "N": 10,
+ "ISEED": [
+ 9999,
+ 100,
+ 200,
+ 300,
+ 401
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 1,
+ "X": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 1,
+ "X_out": [
+ 9999,
+ 0.7221151762867244,
+ 0.3059602026783388,
+ 0.7615758157127068,
+ 0.6079652337045935,
+ 0.0786368892901983,
+ 0.4000379493120114,
+ 0.10082534071584703,
+ 0.23506144863762657,
+ 0.17051886842240904,
+ 0.009087995793297665
+ ],
+ "ISEED_out": [
+ 9999,
+ 37,
+ 919,
+ 1099,
+ 2025
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json
new file mode 100644
index 000000000000..120ac928693b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json
@@ -0,0 +1,37 @@
+{
+ "N": 5,
+ "ISEED": [
+ 9999,
+ 0,
+ 1,
+ 2,
+ 3
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 1,
+ "X": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 1,
+ "X_out": [
+ 9999,
+ 0.13185632717602047,
+ 0.23381133728018355,
+ 0.321647369501445,
+ 0.7105395653957878,
+ 0.021072610098311628
+ ],
+ "ISEED_out": [
+ 9999,
+ 86,
+ 1283,
+ 2995,
+ 1711
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json
new file mode 100644
index 000000000000..5be2930ac294
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json
@@ -0,0 +1,33 @@
+{
+ "N": 5,
+ "ISEED": [
+ 0,
+ 1,
+ 2,
+ 3
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 0.23381133728018355,
+ 0.321647369501445,
+ 0.7105395653957878,
+ 0.021072610098311628
+ ],
+ "ISEED_out": [
+ 86,
+ 1283,
+ 2995,
+ 1711
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
new file mode 100644
index 000000000000..038807ddc32e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
@@ -0,0 +1,228 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Int32Array = require( '@stdlib/array/int32' );
+var dlaruv = require( './../lib/dlaruv.js' );
+
+
+// FIXTURES //
+
+var SMALL_N = require( './fixtures/small_n.json' );
+var MEDIUM_N = require( './fixtures/medium_n.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 3', function test( t ) {
+ t.strictEqual( dlaruv.length, 3, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers drawn from a uniform (0,1) distribution (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( seed, data.N, x );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers drawn from a uniform (0,1) distribution (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( seed, data.N, x );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+ var seed;
+ var out;
+ var x;
+
+ seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ x = new Float64Array( 5 );
+
+ out = dlaruv( seed, 5, x );
+
+ t.strictEqual( out, x, 'same reference' );
+ t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the output array unchanged and does not update the seed', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( seed, 0, x );
+ t.deepEqual( x, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ dlaruv( seed, -1, x );
+ t.deepEqual( x, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function does not modify elements beyond the first `N` elements', function test( t ) {
+ var expected;
+ var data;
+ var seed;
+ var x;
+
+ data = SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( [ 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0 ] );
+
+ dlaruv( seed, data.N, x );
+
+ expected = new Float64Array( data.X_out.concat( [ 9.0, 9.0 ] ) );
+ t.deepEqual( x, expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function updates the seed such that successive invocations continue the same stream', function test( t ) {
+ var data;
+ var seed;
+ var x1;
+ var x2;
+
+ data = MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x1 = new Float64Array( 5 );
+ x2 = new Float64Array( 5 );
+
+ dlaruv( seed, 5, x1 );
+ dlaruv( seed, 5, x2 );
+
+ t.deepEqual( x1, new Float64Array( data.X_out.slice( 0, 5 ) ), 'returns expected value' );
+ t.deepEqual( x2, new Float64Array( data.X_out.slice( 5 ) ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function produces deterministic output for the same seed', function test( t ) {
+ var seed1;
+ var seed2;
+ var x1;
+ var x2;
+
+ seed1 = new Int32Array( [ 0, 1, 2, 3 ] );
+ seed2 = new Int32Array( [ 0, 1, 2, 3 ] );
+ x1 = new Float64Array( 5 );
+ x2 = new Float64Array( 5 );
+
+ dlaruv( seed1, 5, x1 );
+ dlaruv( seed2, 5, x2 );
+
+ t.deepEqual( x1, x2, 'returns expected value' );
+ t.deepEqual( seed1, seed2, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1), including for extremal seeds', function test( t ) {
+ var seeds;
+ var seed;
+ var bool;
+ var x;
+ var i;
+ var j;
+
+ // Include the extremal seeds for which the generated values are closest to the boundaries of the unit interval...
+ seeds = [
+ [ 100, 200, 300, 401 ],
+ [ 0, 0, 0, 1 ],
+ [ 0, 0, 0, 4095 ],
+ [ 4095, 4095, 4095, 4095 ],
+ [ 4095, 0, 0, 1 ],
+ [ 1, 1, 1, 1 ]
+ ];
+ for ( j = 0; j < seeds.length; j++ ) {
+ seed = new Int32Array( seeds[ j ] );
+ x = new Float64Array( 128 );
+
+ dlaruv( seed, 128, x );
+
+ bool = true;
+ for ( i = 0; i < x.length; i++ ) {
+ if ( x[ i ] <= 0.0 || x[ i ] >= 1.0 ) {
+ bool = false;
+ break;
+ }
+ }
+ t.ok( bool, 'returns expected value' );
+ }
+
+ t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+ var seed;
+ var x;
+
+ seed = new Int32Array( [ 100, 200, 300, 401 ] );
+ x = new Float64Array( 130 );
+
+ dlaruv( seed, 130, x );
+
+ t.ok( x[ 127 ] > 0.0, 'returns expected value' );
+ t.strictEqual( x[ 128 ], 0.0, 'returns expected value' );
+ t.strictEqual( x[ 129 ], 0.0, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js
new file mode 100644
index 000000000000..e095ef9bce2e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dlaruv = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': IS_BROWSER
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+ t.strictEqual( typeof dlaruv.ndarray, 'function', 'method is a function' );
+ t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+ var dlaruv = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlaruv, mock, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return mock;
+ }
+
+ function mock() {
+ // Mock...
+ }
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+ var dlaruv;
+ var main;
+
+ main = require( './../lib/dlaruv.js' );
+
+ dlaruv = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlaruv, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
new file mode 100644
index 000000000000..ebe51750ead4
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
@@ -0,0 +1,337 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Int32Array = require( '@stdlib/array/int32' );
+var dlaruv = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+var SMALL_N = require( './fixtures/small_n.json' );
+var MEDIUM_N = require( './fixtures/medium_n.json' );
+var OFFSET_SMALL_N = require( './fixtures/offsets/small_n.json' );
+var OFFSET_MEDIUM_N = require( './fixtures/offsets/medium_n.json' );
+var NEGATIVE_STRIDES_SMALL_N = require( './fixtures/negative_strides/small_n.json' );
+var NEGATIVE_STRIDES_MEDIUM_N = require( './fixtures/negative_strides/medium_n.json' );
+var LARGE_STRIDES_SMALL_N = require( './fixtures/large_strides/small_n.json' );
+var LARGE_STRIDES_MEDIUM_N = require( './fixtures/large_strides/medium_n.json' );
+var MIXED_STRIDES_SMALL_N = require( './fixtures/mixed_strides/small_n.json' );
+var MIXED_STRIDES_MEDIUM_N = require( './fixtures/mixed_strides/medium_n.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+ t.strictEqual( dlaruv.length, 7, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers drawn from a uniform (0,1) distribution (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers drawn from a uniform (0,1) distribution (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing positive strides (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = LARGE_STRIDES_SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing positive strides (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = LARGE_STRIDES_MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing mixed sign strides (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = MIXED_STRIDES_SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing mixed sign strides (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = MIXED_STRIDES_MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing negative strides (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = NEGATIVE_STRIDES_SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing negative strides (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = NEGATIVE_STRIDES_MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing index offsets (small N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = OFFSET_SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing index offsets (medium N)', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = OFFSET_MEDIUM_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( data.N, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+ var seed;
+ var out;
+ var x;
+
+ seed = new Int32Array( [ 0, 1, 2, 3 ] );
+ x = new Float64Array( 5 );
+
+ out = dlaruv( 5, seed, 1, 0, x, 1, 0 );
+
+ t.strictEqual( out, x, 'same reference' );
+ t.end();
+});
+
+tape( 'the function does not modify elements outside the indexed range', function test( t ) {
+ var expected;
+ var data;
+ var seed;
+ var vals;
+ var x;
+
+ data = SMALL_N;
+
+ // Interleave the output with sentinel values and generate in reverse order...
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( [ 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0 ] );
+
+ dlaruv( data.N, seed, 1, 0, x, -2, 8 );
+
+ vals = data.X_out;
+ expected = new Float64Array( [ vals[ 4 ], 9.0, vals[ 3 ], 9.0, vals[ 2 ], 9.0, vals[ 1 ], 9.0, vals[ 0 ], 9.0 ] );
+ t.deepEqual( x, expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function updates the seed such that successive invocations continue the same stream', function test( t ) {
+ var data;
+ var seed;
+ var x1;
+ var x2;
+
+ data = MEDIUM_N;
+
+ // Provide the seed via an index offset...
+ seed = new Int32Array( [ 0 ].concat( data.ISEED ) );
+ x1 = new Float64Array( 5 );
+ x2 = new Float64Array( 5 );
+
+ dlaruv( 5, seed, 1, 1, x1, 1, 0 );
+ dlaruv( 5, seed, 1, 1, x2, 1, 0 );
+
+ t.deepEqual( x1, new Float64Array( data.X_out.slice( 0, 5 ) ), 'returns expected value' );
+ t.deepEqual( x2, new Float64Array( data.X_out.slice( 5 ) ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( [ 0 ].concat( data.ISEED_out ) ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the output array unchanged and does not update the seed', function test( t ) {
+ var seed;
+ var data;
+ var x;
+
+ data = SMALL_N;
+
+ seed = new Int32Array( data.ISEED );
+ x = new Float64Array( data.X );
+
+ dlaruv( 0, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ dlaruv( -1, seed, data.strideISEED, data.offsetISEED, x, data.strideX, data.offsetX );
+ t.deepEqual( x, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( seed, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1)', function test( t ) {
+ var bool;
+ var seed;
+ var x;
+ var i;
+
+ seed = new Int32Array( [ 100, 200, 300, 401 ] );
+ x = new Float64Array( 128 );
+
+ dlaruv( 128, seed, 1, 0, x, 1, 0 );
+
+ bool = true;
+ for ( i = 0; i < x.length; i++ ) {
+ if ( x[ i ] <= 0.0 || x[ i ] >= 1.0 ) {
+ bool = false;
+ break;
+ }
+ }
+ t.ok( bool, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+ var seed;
+ var x;
+
+ seed = new Int32Array( [ 100, 200, 300, 401 ] );
+ x = new Float64Array( 130 );
+
+ dlaruv( 130, seed, 1, 0, x, 1, 0 );
+
+ t.ok( x[ 127 ] > 0.0, 'returns expected value' );
+ t.strictEqual( x[ 128 ], 0.0, 'returns expected value' );
+ t.strictEqual( x[ 129 ], 0.0, 'returns expected value' );
+
+ t.end();
+});