From 3a73dd7025999ed30131a6f957936334ef8059a3 Mon Sep 17 00:00:00 2001
From: iampratik13 <bhagwatpratik781@gmail.com>
Date: Tue, 2 Jun 2026 17:26:19 +0530
Subject: [PATCH 1/3] feat: add lapack/base/dlaruv

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown_pkg_readmes
    status: passed
  - task: lint_markdown_docs
    status: na
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: passed
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/lapack/base/dlaruv/README.md      | 243 ++++++++++++++
 .../lapack/base/dlaruv/benchmark/benchmark.js |  98 ++++++
 .../dlaruv/benchmark/benchmark.ndarray.js     |  98 ++++++
 .../@stdlib/lapack/base/dlaruv/docs/repl.txt  |  91 ++++++
 .../lapack/base/dlaruv/docs/types/index.d.ts  | 105 +++++++
 .../lapack/base/dlaruv/docs/types/test.ts     | 214 +++++++++++++
 .../lapack/base/dlaruv/examples/index.js      |  31 ++
 .../@stdlib/lapack/base/dlaruv/lib/base.js    | 254 +++++++++++++++
 .../@stdlib/lapack/base/dlaruv/lib/dlaruv.js  |  58 ++++
 .../@stdlib/lapack/base/dlaruv/lib/index.js   |  72 +++++
 .../@stdlib/lapack/base/dlaruv/lib/main.js    |  35 +++
 .../@stdlib/lapack/base/dlaruv/lib/ndarray.js |  62 ++++
 .../@stdlib/lapack/base/dlaruv/package.json   |  70 +++++
 .../test/fixtures/large_strides/medium_n.json |  71 +++++
 .../test/fixtures/large_strides/small_n.json  |  51 +++
 .../base/dlaruv/test/fixtures/medium_n.json   |  43 +++
 .../test/fixtures/mixed_strides/medium_n.json |  71 +++++
 .../test/fixtures/mixed_strides/small_n.json  |  51 +++
 .../fixtures/negative_strides/medium_n.json   |  43 +++
 .../fixtures/negative_strides/small_n.json    |  33 ++
 .../test/fixtures/offsets/medium_n.json       |  47 +++
 .../dlaruv/test/fixtures/offsets/small_n.json |  37 +++
 .../base/dlaruv/test/fixtures/small_n.json    |  33 ++
 .../lapack/base/dlaruv/test/test.dlaruv.js    | 179 +++++++++++
 .../@stdlib/lapack/base/dlaruv/test/test.js   |  82 +++++
 .../lapack/base/dlaruv/test/test.ndarray.js   | 297 ++++++++++++++++++
 26 files changed, 2469 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/package.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js
 create mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js

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..36b71af693a5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
@@ -0,0 +1,243 @@
+<!--
+
+@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.
+
+-->
+
+# dlaruv
+
+> Return a vector of `n` random real numbers from a uniform (0,1) distribution.
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+```
+
+#### dlaruv( N, ISEED, X )
+
+Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+var X = new Float64Array( 3 );
+
+dlaruv( 3, ISEED, X );
+// X => <Float64Array>
+```
+
+The function has the following parameters:
+
+-   **N**: number of random numbers to generate. Must be at most `128`.
+-   **ISEED**: [`Int32Array`][mdn-int32array] seed array of four integers. Each element must be between `0` and `4095`, and `ISEED[3]` must be odd. On exit, the seed is updated.
+-   **X**: output [`Float64Array`][mdn-float64array].
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+<!-- eslint-disable stdlib/capitalized-comments -->
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+// Initial arrays...
+var ISEED0 = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var X0 = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+
+// Create offset views...
+var ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dlaruv( 3, ISEED1, X1 );
+// X0 => <Float64Array>
+```
+
+#### dlaruv.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
+
+Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+var X = new Float64Array( 3 );
+
+dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+// X => <Float64Array>
+```
+
+The function has the following additional parameters:
+
+-   **strideISEED**: stride length for `ISEED`.
+-   **offsetISEED**: starting index for `ISEED`.
+-   **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,
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var X = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+dlaruv.ndarray( 3, ISEED, 1, 1, X, 1, 2 );
+// X => <Float64Array>
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   `dlaruv()` corresponds to the [LAPACK][LAPACK] function [`dlaruv`][lapack-dlaruv].
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+
+var ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
+var X = new Float64Array( 10 );
+
+dlaruv( X.length, ISEED, X );
+
+console.log( X );
+console.log( ISEED );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+TODO
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlaruv]: https://netlib.org/lapack/explore-html/d9/d0f/group__laruv.html
+
+[mdn-int32array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
+
+[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+</section>
+
+<!-- /.links -->
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..2bde48eddaf8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
@@ -0,0 +1,98 @@
+/**
+* @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 min = require( '@stdlib/math/base/special/min' );
+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 ISEED = 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, ISEED, 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 min2;
+	var len;
+	var max;
+	var f;
+	var i;
+
+	min2 = 0; // 10^min
+	max = 2;  // 10^max (capped at 128)
+
+	for ( i = min2; i <= max; i++ ) {
+		len = min( pow( 10, i ), 128 );
+		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..59b9d41ead5e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
@@ -0,0 +1,98 @@
+/**
+* @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 min = require( '@stdlib/math/base/special/min' );
+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 ISEED = 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, ISEED, 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 min2;
+	var len;
+	var max;
+	var f;
+	var i;
+
+	min2 = 0; // 10^min
+	max = 2;  // 10^max (capped at 128)
+
+	for ( i = min2; i <= max; i++ ) {
+		len = min( pow( 10, i ), 128 );
+		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..208d705120ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
@@ -0,0 +1,91 @@
+
+{{alias}}( N, ISEED, X )
+    Returns a vector of `N` random real numbers 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 `ISEED`.
+
+    Parameters
+    ----------
+    N: integer
+        Number of random numbers to generate (N <= 128).
+
+    ISEED: Int32Array
+        Seed array of four integers. Each element must be between `0` and
+        `4095`, and `ISEED[3]` must be odd.
+
+    X: Float64Array
+        Output array.
+
+    Returns
+    -------
+    X: Float64Array
+        Output array `X` filled with random numbers.
+
+    Examples
+    --------
+    > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+    > var X = new {{alias:@stdlib/array/float64}}( 10 );
+    > {{alias}}( X.length, ISEED, X )
+    <Float64Array>
+
+    // Using typed array views:
+    > var ISEED0 = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3, 3 ] );
+    > var X0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+    > var ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 );
+    > var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 3, ISEED1, X1 )
+    <Float64Array>
+
+
+{{alias}}.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
+    Returns a vector of `N` random real numbers 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 `ISEED`.
+
+    Parameters
+    ----------
+    N: integer
+        Number of random numbers to generate (N <= 128).
+
+    ISEED: Int32Array
+        Seed array of four integers. Each element must be between `0` and
+        `4095`, and `ISEED[3]` must be odd.
+
+    strideISEED: integer
+        Stride length for `ISEED`.
+
+    offsetISEED: integer
+        Starting index for `ISEED`.
+
+    X: Float64Array
+        Output array.
+
+    strideX: integer
+        Stride length for `X`.
+
+    offsetX: integer
+        Starting index for `X`.
+
+    Returns
+    -------
+    X: Float64Array
+        Output array `X` filled with random numbers.
+
+    Examples
+    --------
+    > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+    > var X = new {{alias:@stdlib/array/float64}}( 10 );
+    > {{alias}}.ndarray( X.length, ISEED, 1, 0, X, 1, 0 )
+    <Float64Array>
+
+    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..f5aa8063905e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
@@ -0,0 +1,105 @@
+/*
+* @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
+
+/// <reference types="@stdlib/types"/>
+
+/**
+* Interface describing `dlaruv`.
+*/
+interface Routine {
+	/**
+	* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+	*
+	* @param N - number of random numbers to generate (N <= 128)
+	* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+	* @param X - output array
+	* @returns output array `X` filled with random numbers
+	*
+	* @example
+	* var Int32Array = require( '@stdlib/array/int32' );
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	* var X = new Float64Array( 3 );
+	*
+	* dlaruv( 3, ISEED, X );
+	* // X => <Float64Array>
+	*/
+	( N: number, ISEED: Int32Array, X: Float64Array ): Float64Array;
+
+	/**
+	* Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+	*
+	* @param N - number of random numbers to generate (N <= 128)
+	* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+	* @param strideISEED - stride length for `ISEED`
+	* @param offsetISEED - starting index for `ISEED`
+	* @param X - output array
+	* @param strideX - stride length for `X`
+	* @param offsetX - starting index for `X`
+	* @returns output array `X` filled with random numbers
+	*
+	* @example
+	* var Int32Array = require( '@stdlib/array/int32' );
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	* var X = new Float64Array( 3 );
+	*
+	* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+	* // X => <Float64Array>
+	*/
+	ndarray( N: number, ISEED: Int32Array, strideISEED: number, offsetISEED: number, X: Float64Array, strideX: number, offsetX: number ): Float64Array;
+}
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @param N - number of random numbers to generate (N <= 128)
+* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param X - output array
+* @returns output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X => <Float64Array>
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+* // X => <Float64Array>
+*/
+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..a5c60f97996a
--- /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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv( 3, ISEED, X ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+	const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv( '5', ISEED, X ); // $ExpectError
+	dlaruv( true, ISEED, X ); // $ExpectError
+	dlaruv( false, ISEED, X ); // $ExpectError
+	dlaruv( null, ISEED, X ); // $ExpectError
+	dlaruv( void 0, ISEED, X ); // $ExpectError
+	dlaruv( [], ISEED, X ); // $ExpectError
+	dlaruv( {}, ISEED, X ); // $ExpectError
+	dlaruv( ( x: number ): number => x, ISEED, X ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an Int32Array...
+{
+	const X = new Float64Array( 3 );
+
+	dlaruv( 3, '5', X ); // $ExpectError
+	dlaruv( 3, 5, X ); // $ExpectError
+	dlaruv( 3, true, X ); // $ExpectError
+	dlaruv( 3, false, X ); // $ExpectError
+	dlaruv( 3, null, X ); // $ExpectError
+	dlaruv( 3, void 0, X ); // $ExpectError
+	dlaruv( 3, [], X ); // $ExpectError
+	dlaruv( 3, {}, X ); // $ExpectError
+	dlaruv( 3, ( 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+
+	dlaruv( 3, ISEED, '5' ); // $ExpectError
+	dlaruv( 3, ISEED, 5 ); // $ExpectError
+	dlaruv( 3, ISEED, true ); // $ExpectError
+	dlaruv( 3, ISEED, false ); // $ExpectError
+	dlaruv( 3, ISEED, null ); // $ExpectError
+	dlaruv( 3, ISEED, void 0 ); // $ExpectError
+	dlaruv( 3, ISEED, [] ); // $ExpectError
+	dlaruv( 3, ISEED, {} ); // $ExpectError
+	dlaruv( 3, ISEED, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv(); // $ExpectError
+	dlaruv( 3 ); // $ExpectError
+	dlaruv( 3, ISEED ); // $ExpectError
+	dlaruv( 3, ISEED, X, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float64Array...
+{
+	const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( 3, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( '5', ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( true, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( false, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( null, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( void 0, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( [], ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( {}, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( ( x: number ): number => x, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( 3, ISEED, '5', 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, true, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, false, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, null, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, void 0, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, [], 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, {}, 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, ( 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( 3, ISEED, 1, '5', X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, true, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, false, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, null, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, void 0, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, [], X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, {}, X, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+
+	dlaruv.ndarray( 3, ISEED, 1, 0, '5', 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, 5, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, true, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, false, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, null, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, void 0, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, [], 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, {}, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, '5', 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, true, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, false, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, null, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, void 0, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, [], 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, {}, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, '5' ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, true ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, false ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, null ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, void 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, [] ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, {} ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	const X = new Float64Array( 3 );
+
+	dlaruv.ndarray(); // $ExpectError
+	dlaruv.ndarray( 3 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 1, 0, X, 1 ); // $ExpectError
+	dlaruv.ndarray( 3, ISEED, 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..ccdb51763cf7
--- /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 ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
+var X = new Float64Array( 10 );
+
+dlaruv( X.length, ISEED, X );
+
+console.log( X );
+console.log( ISEED );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
new file mode 100644
index 000000000000..e8fdfe1d6c0c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
@@ -0,0 +1,254 @@
+/**
+* @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/min' );
+
+
+// VARIABLES //
+
+var LV = 128;
+var IPW2 = 4096;
+var R = 1.0 / IPW2;
+
+/*
+* MM table: 128 x 4 (row-major). Each row i contains the multiplier for the (i+1)-th power of the base multiplier modulo 2^48.
+* MM[i][j] = MM_TABLE[ i ][ j ], 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 from a uniform (0,1) distribution.
+*
+* @private
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {integer} strideISEED - stride length for `ISEED`
+* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
+* @param {Float64Array} X - output array
+* @param {integer} strideX - stride length for `X`
+* @param {NonNegativeInteger} offsetX - starting index for `X`
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
+* // X => <Float64Array>
+*/
+function dlaruv( N, ISEED, strideISEED, offsetISEED, 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 < 1 ) {
+		return X;
+	}
+
+	// Copy seed values into local variables...
+	i1 = ISEED[ offsetISEED ];
+	i2 = ISEED[ offsetISEED + strideISEED ];
+	i3 = ISEED[ offsetISEED + ( 2 * strideISEED ) ];
+	i4 = ISEED[ offsetISEED + ( 3 * strideISEED ) ];
+
+	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:
+	ISEED[ offsetISEED ] = it1;
+	ISEED[ offsetISEED + strideISEED ] = it2;
+	ISEED[ offsetISEED + ( 2 * strideISEED ) ] = it3;
+	ISEED[ offsetISEED + ( 3 * strideISEED ) ] = it4;
+
+	return X;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
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..07fb1b400670
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
@@ -0,0 +1,58 @@
+/**
+* @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 format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {Float64Array} X - output array
+* @throws {RangeError} first argument must be a nonnegative integer
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X => <Float64Array>
+*/
+function dlaruv( N, ISEED, X ) {
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	return base( N, ISEED, 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..03c2ef30922d
--- /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 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X => <Float64Array>
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+* // X => <Float64Array>
+*/
+
+// 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..3548a7717e36
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
@@ -0,0 +1,62 @@
+/**
+* @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 format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+*
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {integer} strideISEED - stride length for `ISEED`
+* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
+* @param {Float64Array} X - output array
+* @param {integer} strideX - stride length for `X`
+* @param {NonNegativeInteger} offsetX - starting index for `X`
+* @throws {RangeError} first argument must be a nonnegative integer
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
+* // X => <Float64Array>
+*/
+function dlaruv( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX ) {
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	return base( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX );
+}
+
+
+// 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..c7aca5466ce7
--- /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 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..fad5632b1f2c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
@@ -0,0 +1,179 @@
+/**
+* @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 throws an error if provided an invalid first argument', function test( t ) {
+	var values;
+	var ISEED;
+	var X;
+	var i;
+
+	values = [
+		-1,
+		-2,
+		-3,
+		-4,
+		-5
+	];
+
+	ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	X = new Float64Array( 5 );
+
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			dlaruv( value, ISEED, X );
+		};
+	}
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, X );
+	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (medium N)', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, X );
+	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function leaves output unchanged when `N` is equal to zero', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( 0, ISEED, X );
+	t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function produces deterministic output for the same seed', function test( t ) {
+	var ISEED1;
+	var ISEED2;
+	var X1;
+	var X2;
+
+	ISEED1 = new Int32Array( [ 0, 1, 2, 3 ] );
+	ISEED2 = new Int32Array( [ 0, 1, 2, 3 ] );
+	X1 = new Float64Array( 5 );
+	X2 = new Float64Array( 5 );
+
+	dlaruv( 5, ISEED1, X1 );
+	dlaruv( 5, ISEED2, X2 );
+
+	t.deepEqual( X1, X2, 'returns expected value' );
+	t.deepEqual( ISEED1, ISEED2, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1)', function test( t ) {
+	var ISEED;
+	var X;
+	var i;
+
+	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+	X = new Float64Array( 128 );
+
+	dlaruv( 128, ISEED, X );
+
+	for ( i = 0; i < X.length; i++ ) {
+		t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+	}
+
+	t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+	var ISEED;
+	var X;
+
+	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+	X = new Float64Array( 130 );
+
+	dlaruv( 130, ISEED, 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..d18d9aaa8072
--- /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/main.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..d7895ac4b8e7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
@@ -0,0 +1,297 @@
+/**
+* @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 throws an error if provided an invalid first argument', function test( t ) {
+	var values;
+	var ISEED;
+	var X;
+	var i;
+
+	values = [
+		-1,
+		-2,
+		-3,
+		-4,
+		-5
+	];
+
+	ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+	X = new Float64Array( 5 );
+
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			dlaruv( value, ISEED, 1, 0, X, 1, 0 );
+		};
+	}
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (medium N)', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports providing positive strides (small N)', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = LARGE_STRIDES_SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = LARGE_STRIDES_MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = MIXED_STRIDES_SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = MIXED_STRIDES_MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = NEGATIVE_STRIDES_SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = NEGATIVE_STRIDES_MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = OFFSET_SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 ISEED;
+	var data;
+	var X;
+
+	data = OFFSET_MEDIUM_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( data.N, ISEED, 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 leaves output unchanged when `N` is equal to zero', function test( t ) {
+	var ISEED;
+	var data;
+	var X;
+
+	data = SMALL_N;
+
+	ISEED = new Int32Array( data.ISEED );
+	X = new Float64Array( data.X );
+
+	dlaruv( 0, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+	t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
+	t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1)', function test( t ) {
+	var ISEED;
+	var X;
+	var i;
+
+	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+	X = new Float64Array( 128 );
+
+	dlaruv( 128, ISEED, 1, 0, X, 1, 0 );
+
+	for ( i = 0; i < X.length; i++ ) {
+		t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+	}
+
+	t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+	var ISEED;
+	var X;
+
+	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+	X = new Float64Array( 130 );
+
+	dlaruv( 130, ISEED, 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();
+});

From f07365b153fb88fb30bac839d51fa7a4a4323822 Mon Sep 17 00:00:00 2001
From: iampratik13 <bhagwatpratik781@gmail.com>
Date: Tue, 23 Jun 2026 12:54:19 +0530
Subject: [PATCH 2/3] chore: suggested changes

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown_pkg_readmes
    status: passed
  - task: lint_markdown_docs
    status: na
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/lapack/base/dlaruv/README.md      |  72 ++---
 .../lapack/base/dlaruv/benchmark/benchmark.js |  21 +-
 .../dlaruv/benchmark/benchmark.ndarray.js     |  21 +-
 .../@stdlib/lapack/base/dlaruv/docs/repl.txt  |  70 ++---
 .../lapack/base/dlaruv/docs/types/index.d.ts  |  74 ++---
 .../lapack/base/dlaruv/examples/index.js      |  10 +-
 .../@stdlib/lapack/base/dlaruv/lib/base.js    | 254 ------------------
 .../@stdlib/lapack/base/dlaruv/lib/dlaruv.js  |  29 +-
 .../@stdlib/lapack/base/dlaruv/lib/ndarray.js | 233 ++++++++++++++--
 .../lapack/base/dlaruv/test/test.dlaruv.js    | 129 ++++-----
 .../lapack/base/dlaruv/test/test.ndarray.js   | 201 ++++++--------
 11 files changed, 493 insertions(+), 621 deletions(-)
 delete mode 100644 lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js

diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
index 36b71af693a5..df3b9a71d31b 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
@@ -20,7 +20,7 @@ limitations under the License.
 
 # dlaruv
 
-> Return a vector of `n` random real numbers from a uniform (0,1) distribution.
+> Return a vector of `n` random real numbers drawn from a uniform (0,1) distribution.
 
 <section class="usage">
 
@@ -30,26 +30,26 @@ limitations under the License.
 var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
 ```
 
-#### dlaruv( N, ISEED, X )
+#### dlaruv( seed, N, x )
 
-Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-var X = new Float64Array( 3 );
+var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+var x = new Float64Array( 3 );
 
-dlaruv( 3, ISEED, X );
-// X => <Float64Array>
+dlaruv( seed, 3, x );
+// x => <Float64Array>
 ```
 
 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`.
--   **ISEED**: [`Int32Array`][mdn-int32array] seed array of four integers. Each element must be between `0` and `4095`, and `ISEED[3]` must be odd. On exit, the seed is updated.
--   **X**: output [`Float64Array`][mdn-float64array].
+-   **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.
 
@@ -60,38 +60,38 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Float64Array = require( '@stdlib/array/float64' );
 
 // Initial arrays...
-var ISEED0 = new Int32Array( [ 0, 0, 1, 2, 3 ] );
-var X0 = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+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 ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
-var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+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( 3, ISEED1, X1 );
-// X0 => <Float64Array>
+dlaruv( seed1, 3, x1 );
+// x0 => <Float64Array>
 ```
 
-#### dlaruv.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
+#### dlaruv.ndarray( N, seed, strideS, offsetS, x, strideX, offsetX )
 
-Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-var X = new Float64Array( 3 );
+var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+var x = new Float64Array( 3 );
 
-dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
-// X => <Float64Array>
+dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+// x => <Float64Array>
 ```
 
 The function has the following additional parameters:
 
--   **strideISEED**: stride length for `ISEED`.
--   **offsetISEED**: starting index for `ISEED`.
--   **strideX**: stride length for `X`.
--   **offsetX**: starting index for `X`.
+-   **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,
 
@@ -101,11 +101,11 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the
 var Int32Array = require( '@stdlib/array/int32' );
 var Float64Array = require( '@stdlib/array/float64' );
 
-var ISEED = new Int32Array( [ 0, 0, 1, 2, 3 ] );
-var X = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+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, ISEED, 1, 1, X, 1, 2 );
-// X => <Float64Array>
+dlaruv.ndarray( 3, seed, 1, 1, x, 1, 2 );
+// x => <Float64Array>
 ```
 
 </section>
@@ -133,13 +133,13 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Float64Array = require( '@stdlib/array/float64' );
 var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
 
-var ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
-var X = new Float64Array( 10 );
+var seed = new Int32Array( [ 1, 23, 456, 3795 ] );
+var x = new Float64Array( 10 );
 
-dlaruv( X.length, ISEED, X );
+dlaruv( seed, x.length, x );
 
-console.log( X );
-console.log( ISEED );
+console.log( x );
+console.log( seed );
 ```
 
 </section>
@@ -232,9 +232,9 @@ TODO
 
 [lapack-dlaruv]: https://netlib.org/lapack/explore-html/d9/d0f/group__laruv.html
 
-[mdn-int32array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
+[@stdlib/array/int32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/int32
 
-[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+[@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
 
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
index 2bde48eddaf8..5c296a57afc8 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
@@ -25,7 +25,6 @@ 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 min = require( '@stdlib/math/base/special/min' );
 var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var dlaruv = require( './../lib/dlaruv.js' );
@@ -41,8 +40,8 @@ var dlaruv = require( './../lib/dlaruv.js' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var ISEED = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
-	var X = new Float64Array( len );
+	var seed = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+	var x = new Float64Array( len );
 	return benchmark;
 
 	/**
@@ -56,13 +55,13 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			dlaruv( len, ISEED, X );
-			if ( isnan( X[ 0 ] ) ) {
+			dlaruv( seed, len, x );
+			if ( isnan( x[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( X[ 0 ] ) ) {
+		if ( isnan( x[ 0 ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );
@@ -79,17 +78,17 @@ function createBenchmark( len ) {
 * @private
 */
 function main() {
-	var min2;
 	var len;
 	var max;
+	var min;
 	var f;
 	var i;
 
-	min2 = 0; // 10^min
-	max = 2;  // 10^max (capped at 128)
+	min = 0; // 2^min
+	max = 7; // 2^max (capped at 128)
 
-	for ( i = min2; i <= max; i++ ) {
-		len = min( pow( 10, i ), 128 );
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 2, i );
 		f = createBenchmark( len );
 		bench( format( '%s:len=%d', pkg, len ), f );
 	}
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
index 59b9d41ead5e..b47958d66e53 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
@@ -25,7 +25,6 @@ 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 min = require( '@stdlib/math/base/special/min' );
 var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var dlaruv = require( './../lib/ndarray.js' );
@@ -41,8 +40,8 @@ var dlaruv = require( './../lib/ndarray.js' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var ISEED = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
-	var X = new Float64Array( len );
+	var seed = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+	var x = new Float64Array( len );
 	return benchmark;
 
 	/**
@@ -56,13 +55,13 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			dlaruv( len, ISEED, 1, 0, X, 1, 0 );
-			if ( isnan( X[ 0 ] ) ) {
+			dlaruv( len, seed, 1, 0, x, 1, 0 );
+			if ( isnan( x[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( X[ 0 ] ) ) {
+		if ( isnan( x[ 0 ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );
@@ -79,17 +78,17 @@ function createBenchmark( len ) {
 * @private
 */
 function main() {
-	var min2;
 	var len;
 	var max;
+	var min;
 	var f;
 	var i;
 
-	min2 = 0; // 10^min
-	max = 2;  // 10^max (capped at 128)
+	min = 0; // 2^min
+	max = 7; // 2^max (capped at 128)
 
-	for ( i = min2; i <= max; i++ ) {
-		len = min( pow( 10, i ), 128 );
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 2, i );
 		f = createBenchmark( len );
 		bench( format( '%s::ndarray:len=%d', pkg, len ), f );
 	}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
index 208d705120ad..9c7bbe0f53fc 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
@@ -1,90 +1,90 @@
 
-{{alias}}( N, ISEED, X )
-    Returns a vector of `N` random real numbers from a uniform (0,1)
+{{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 `ISEED`.
+    The function mutates the input seed array `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).
 
-    ISEED: Int32Array
-        Seed array of four integers. Each element must be between `0` and
-        `4095`, and `ISEED[3]` must be odd.
-
-    X: Float64Array
+    x: Float64Array
         Output array.
 
     Returns
     -------
-    X: Float64Array
-        Output array `X` filled with random numbers.
+    x: Float64Array
+        Output array `x` filled with random numbers.
 
     Examples
     --------
-    > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
-    > var X = new {{alias:@stdlib/array/float64}}( 10 );
-    > {{alias}}( X.length, ISEED, X )
+    > var seed = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+    > var x = new {{alias:@stdlib/array/float64}}( 10 );
+    > {{alias}}( seed, 10, x )
     <Float64Array>
 
     // Using typed array views:
-    > var ISEED0 = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3, 3 ] );
-    > var X0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
-    > var ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 );
-    > var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 );
-    > {{alias}}( 3, ISEED1, X1 )
+    > var seed0 = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3, 3 ] );
+    > var x0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+    > var seed1 = new Int32Array( seed0.buffer, seed0.BYTES_PER_ELEMENT*1 );
+    > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( seed1, 3, x1 )
     <Float64Array>
 
 
-{{alias}}.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
-    Returns a vector of `N` random real numbers from a uniform (0,1)
+{{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 `ISEED`.
+    The function mutates the input seed array `seed`.
 
     Parameters
     ----------
     N: integer
         Number of random numbers to generate (N <= 128).
 
-    ISEED: Int32Array
+    seed: Int32Array
         Seed array of four integers. Each element must be between `0` and
-        `4095`, and `ISEED[3]` must be odd.
+        `4095`, and `seed[3]` must be odd.
 
-    strideISEED: integer
-        Stride length for `ISEED`.
+    strideS: integer
+        Stride length for `seed`.
 
-    offsetISEED: integer
-        Starting index for `ISEED`.
+    offsetS: integer
+        Starting index for `seed`.
 
-    X: Float64Array
+    x: Float64Array
         Output array.
 
     strideX: integer
-        Stride length for `X`.
+        Stride length for `x`.
 
     offsetX: integer
-        Starting index for `X`.
+        Starting index for `x`.
 
     Returns
     -------
-    X: Float64Array
-        Output array `X` filled with random numbers.
+    x: Float64Array
+        Output array `x` filled with random numbers.
 
     Examples
     --------
-    > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
-    > var X = new {{alias:@stdlib/array/float64}}( 10 );
-    > {{alias}}.ndarray( X.length, ISEED, 1, 0, X, 1, 0 )
+    > var seed = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+    > var x = new {{alias:@stdlib/array/float64}}( 10 );
+    > {{alias}}.ndarray( 10, seed, 1, 0, x, 1, 0 )
     <Float64Array>
 
     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
index f5aa8063905e..735ccb4dda3c 100644
--- 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
@@ -25,77 +25,77 @@
 */
 interface Routine {
 	/**
-	* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+	* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
 	*
-	* @param N - number of random numbers to generate (N <= 128)
-	* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-	* @param X - output array
-	* @returns output array `X` filled with random numbers
+	* @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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	* var X = new Float64Array( 3 );
+	* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+	* var x = new Float64Array( 3 );
 	*
-	* dlaruv( 3, ISEED, X );
-	* // X => <Float64Array>
+	* dlaruv( seed, 3, x );
+	* // x => <Float64Array>
 	*/
-	( N: number, ISEED: Int32Array, X: Float64Array ): Float64Array;
+	( seed: Int32Array, N: number, x: Float64Array ): Float64Array;
 
 	/**
-	* Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+	* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution using alternative indexing semantics.
 	*
-	* @param N - number of random numbers to generate (N <= 128)
-	* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-	* @param strideISEED - stride length for `ISEED`
-	* @param offsetISEED - starting index for `ISEED`
-	* @param X - output array
-	* @param strideX - stride length for `X`
-	* @param offsetX - starting index for `X`
-	* @returns output array `X` filled with random numbers
+	* @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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	* var X = new Float64Array( 3 );
+	* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+	* var x = new Float64Array( 3 );
 	*
-	* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
-	* // X => <Float64Array>
+	* dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+	* // x => <Float64Array>
 	*/
-	ndarray( N: number, ISEED: Int32Array, strideISEED: number, offsetISEED: number, X: Float64Array, strideX: number, offsetX: number ): Float64Array;
+	ndarray( N: number, seed: Int32Array, strideS: number, offsetS: number, x: Float64Array, strideX: number, offsetX: number ): Float64Array;
 }
 
 /**
-* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
 *
-* @param N - number of random numbers to generate (N <= 128)
-* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-* @param X - output array
-* @returns output array `X` filled with random numbers
+* @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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv( 3, ISEED, X );
-* // X => <Float64Array>
+* dlaruv( seed, 3, x );
+* // x => <Float64Array>
 *
 * @example
 * var Int32Array = require( '@stdlib/array/int32' );
 * var Float64Array = require( '@stdlib/array/float64' );
 *
-* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
-* // X => <Float64Array>
+* dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+* // x => <Float64Array>
 */
 declare var dlaruv: Routine;
 
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
index ccdb51763cf7..19c141d67f10 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
@@ -22,10 +22,10 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Float64Array = require( '@stdlib/array/float64' );
 var dlaruv = require( './../lib' );
 
-var ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
-var X = new Float64Array( 10 );
+var seed = new Int32Array( [ 1, 23, 456, 3795 ] );
+var x = new Float64Array( 10 );
 
-dlaruv( X.length, ISEED, X );
+dlaruv( seed, x.length, x );
 
-console.log( X );
-console.log( ISEED );
+console.log( x );
+console.log( seed );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
deleted file mode 100644
index e8fdfe1d6c0c..000000000000
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
+++ /dev/null
@@ -1,254 +0,0 @@
-/**
-* @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/min' );
-
-
-// VARIABLES //
-
-var LV = 128;
-var IPW2 = 4096;
-var R = 1.0 / IPW2;
-
-/*
-* MM table: 128 x 4 (row-major). Each row i contains the multiplier for the (i+1)-th power of the base multiplier modulo 2^48.
-* MM[i][j] = MM_TABLE[ i ][ j ], 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 from a uniform (0,1) distribution.
-*
-* @private
-* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
-* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-* @param {integer} strideISEED - stride length for `ISEED`
-* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
-* @param {Float64Array} X - output array
-* @param {integer} strideX - stride length for `X`
-* @param {NonNegativeInteger} offsetX - starting index for `X`
-* @returns {Float64Array} output array `X` filled with random numbers
-*
-* @example
-* var Int32Array = require( '@stdlib/array/int32' );
-* var Float64Array = require( '@stdlib/array/float64' );
-*
-* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
-*
-* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
-* // X => <Float64Array>
-*/
-function dlaruv( N, ISEED, strideISEED, offsetISEED, 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 < 1 ) {
-		return X;
-	}
-
-	// Copy seed values into local variables...
-	i1 = ISEED[ offsetISEED ];
-	i2 = ISEED[ offsetISEED + strideISEED ];
-	i3 = ISEED[ offsetISEED + ( 2 * strideISEED ) ];
-	i4 = ISEED[ offsetISEED + ( 3 * strideISEED ) ];
-
-	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:
-	ISEED[ offsetISEED ] = it1;
-	ISEED[ offsetISEED + strideISEED ] = it2;
-	ISEED[ offsetISEED + ( 2 * strideISEED ) ] = it3;
-	ISEED[ offsetISEED + ( 3 * strideISEED ) ] = it4;
-
-	return X;
-}
-
-
-// EXPORTS //
-
-module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
index 07fb1b400670..82f59253544b 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
@@ -20,36 +20,31 @@
 
 // MODULES //
 
-var format = require( '@stdlib/string/format' );
-var base = require( './base.js' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
 
 /**
-* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution.
 *
-* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
-* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-* @param {Float64Array} X - output array
-* @throws {RangeError} first argument must be a nonnegative integer
-* @returns {Float64Array} output array `X` filled with random numbers
+* @param {Int32Array} seed - seed array of four integers
+* @param {integer} 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv( 3, ISEED, X );
-* // X => <Float64Array>
+* dlaruv( seed, 3, x );
+* // x => <Float64Array>
 */
-function dlaruv( N, ISEED, X ) {
-	if ( N < 0 ) {
-		throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
-	}
-	return base( N, ISEED, 1, 0, X, 1, 0 );
+function dlaruv( seed, N, x ) {
+	return ndarray( N, seed, 1, 0, x, 1, 0 );
 }
 
 
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
index 3548a7717e36..ac87a557ba9d 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
@@ -16,44 +16,235 @@
 * limitations under the License.
 */
 
+/* eslint-disable max-len */
+
 'use strict';
 
 // MODULES //
 
-var format = require( '@stdlib/string/format' );
-var base = require( './base.js' );
+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). Each row i contains the multiplier for the (i+1)-th power of the base multiplier modulo 2^48.
+* MM[i][j] = MM_TABLE[ i ][ j ], 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 from a uniform (0,1) distribution using alternative indexing semantics.
-*
-* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
-* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
-* @param {integer} strideISEED - stride length for `ISEED`
-* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
-* @param {Float64Array} X - output array
-* @param {integer} strideX - stride length for `X`
-* @param {NonNegativeInteger} offsetX - starting index for `X`
-* @throws {RangeError} first argument must be a nonnegative integer
-* @returns {Float64Array} output array `X` filled with random numbers
+* Returns a vector of `N` random real numbers drawn from a uniform (0,1) distribution using alternative indexing semantics.
+*
+* @param {integer} 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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
-* // X => <Float64Array>
+* dlaruv( 3, seed, 1, 0, x, 1, 0 );
+* // x => <Float64Array>
 */
-function dlaruv( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX ) {
-	if ( N < 0 ) {
-		throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
+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 < 1 ) {
+		return x;
 	}
-	return base( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX );
+
+	// Copy seed values into local variables:
+	i1 = seed[ offsetS ];
+	i2 = seed[ offsetS + strideS ];
+	i3 = seed[ offsetS + ( 2 * strideS ) ];
+	i4 = seed[ offsetS + ( 3 * strideS ) ];
+
+	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;
 }
 
 
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
index fad5632b1f2c..d13063b5c6c6 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
@@ -45,135 +45,106 @@ tape( 'the function has an arity of 3', function test( t ) {
 	t.end();
 });
 
-tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
-	var values;
-	var ISEED;
-	var X;
-	var i;
-
-	values = [
-		-1,
-		-2,
-		-3,
-		-4,
-		-5
-	];
-
-	ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	X = new Float64Array( 5 );
-
-	for ( i = 0; i < values.length; i++ ) {
-		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
-	}
-	t.end();
-
-	function badValue( value ) {
-		return function badValue() {
-			dlaruv( value, ISEED, X );
-		};
-	}
-});
-
-tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
-	var ISEED;
+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;
+	var x;
 
 	data = SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, X );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+	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 from a uniform (0,1) distribution (medium N)', function test( t ) {
-	var ISEED;
+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;
+	var x;
 
 	data = MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, X );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+	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 leaves output unchanged when `N` is equal to zero', function test( t ) {
-	var ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( 0, ISEED, X );
-	t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+	dlaruv( seed, 0, 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 produces deterministic output for the same seed', function test( t ) {
-	var ISEED1;
-	var ISEED2;
-	var X1;
-	var X2;
+	var seed1;
+	var seed2;
+	var x1;
+	var x2;
 
-	ISEED1 = new Int32Array( [ 0, 1, 2, 3 ] );
-	ISEED2 = new Int32Array( [ 0, 1, 2, 3 ] );
-	X1 = new Float64Array( 5 );
-	X2 = new Float64Array( 5 );
+	seed1 = new Int32Array( [ 0, 1, 2, 3 ] );
+	seed2 = new Int32Array( [ 0, 1, 2, 3 ] );
+	x1 = new Float64Array( 5 );
+	x2 = new Float64Array( 5 );
 
-	dlaruv( 5, ISEED1, X1 );
-	dlaruv( 5, ISEED2, X2 );
+	dlaruv( seed1, 5, x1 );
+	dlaruv( seed2, 5, x2 );
 
-	t.deepEqual( X1, X2, 'returns expected value' );
-	t.deepEqual( ISEED1, ISEED2, 'returns expected value' );
+	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)', function test( t ) {
-	var ISEED;
-	var X;
+	var seed;
+	var x;
 	var i;
 
-	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
-	X = new Float64Array( 128 );
+	seed = new Int32Array( [ 100, 200, 300, 401 ] );
+	x = new Float64Array( 128 );
 
-	dlaruv( 128, ISEED, X );
+	dlaruv( seed, 128, x );
 
-	for ( i = 0; i < X.length; i++ ) {
-		t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+	for ( i = 0; i < x.length; i++ ) {
+		t.ok( x[ i ] > 0.0 && x[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + x[ i ] );
 	}
 
 	t.end();
 });
 
 tape( 'the function generates at most 128 values per call', function test( t ) {
-	var ISEED;
-	var X;
+	var seed;
+	var x;
 
-	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
-	X = new Float64Array( 130 );
+	seed = new Int32Array( [ 100, 200, 300, 401 ] );
+	x = new Float64Array( 130 );
 
-	dlaruv( 130, ISEED, X );
+	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.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.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
index d7895ac4b8e7..3c7a738f32f1 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
@@ -55,243 +55,214 @@ tape( 'the function has an arity of 7', function test( t ) {
 	t.end();
 });
 
-tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
-	var values;
-	var ISEED;
-	var X;
-	var i;
-
-	values = [
-		-1,
-		-2,
-		-3,
-		-4,
-		-5
-	];
-
-	ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	X = new Float64Array( 5 );
-
-	for ( i = 0; i < values.length; i++ ) {
-		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
-	}
-	t.end();
-
-	function badValue( value ) {
-		return function badValue() {
-			dlaruv( value, ISEED, 1, 0, X, 1, 0 );
-		};
-	}
-});
-
-tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
-	var ISEED;
+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;
+	var x;
 
 	data = SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+	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 from a uniform (0,1) distribution (medium N)', function test( t ) {
-	var ISEED;
+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;
+	var x;
 
 	data = MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = LARGE_STRIDES_SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = LARGE_STRIDES_MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = MIXED_STRIDES_SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = MIXED_STRIDES_MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = NEGATIVE_STRIDES_SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = NEGATIVE_STRIDES_MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = OFFSET_SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = OFFSET_MEDIUM_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+	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 leaves output unchanged when `N` is equal to zero', function test( t ) {
-	var ISEED;
+	var seed;
 	var data;
-	var X;
+	var x;
 
 	data = SMALL_N;
 
-	ISEED = new Int32Array( data.ISEED );
-	X = new Float64Array( data.X );
+	seed = new Int32Array( data.ISEED );
+	x = new Float64Array( data.X );
 
-	dlaruv( 0, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
-	t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
-	t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+	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' );
 
 	t.end();
 });
 
 tape( 'the function generates values in the open interval (0,1)', function test( t ) {
-	var ISEED;
-	var X;
+	var seed;
+	var x;
 	var i;
 
-	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
-	X = new Float64Array( 128 );
+	seed = new Int32Array( [ 100, 200, 300, 401 ] );
+	x = new Float64Array( 128 );
 
-	dlaruv( 128, ISEED, 1, 0, X, 1, 0 );
+	dlaruv( 128, seed, 1, 0, x, 1, 0 );
 
-	for ( i = 0; i < X.length; i++ ) {
-		t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+	for ( i = 0; i < x.length; i++ ) {
+		t.ok( x[ i ] > 0.0 && x[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + x[ i ] );
 	}
 
 	t.end();
 });
 
 tape( 'the function generates at most 128 values per call', function test( t ) {
-	var ISEED;
-	var X;
+	var seed;
+	var x;
 
-	ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
-	X = new Float64Array( 130 );
+	seed = new Int32Array( [ 100, 200, 300, 401 ] );
+	x = new Float64Array( 130 );
 
-	dlaruv( 130, ISEED, 1, 0, X, 1, 0 );
+	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.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();
 });

From bfea793497cd0a2eda8244a45fb6251ab669a0f6 Mon Sep 17 00:00:00 2001
From: iampratik13 <bhagwatpratik781@gmail.com>
Date: Tue, 23 Jun 2026 13:11:57 +0530
Subject: [PATCH 3/3] fix: update signatures and parameter naming

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown_pkg_readmes
    status: na
  - task: lint_markdown_docs
    status: na
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../lapack/base/dlaruv/docs/types/test.ts     | 86 +++++++++----------
 .../@stdlib/lapack/base/dlaruv/lib/index.js   | 16 ++--
 2 files changed, 51 insertions(+), 51 deletions(-)

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
index a5c60f97996a..8fded75a2ffd 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
@@ -23,66 +23,66 @@ import dlaruv = require( './index' );
 
 // The function returns a Float64Array...
 {
-	const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	const X = new Float64Array( 3 );
+	const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+	const x = new Float64Array( 3 );
 
-	dlaruv( 3, ISEED, X ); // $ExpectType Float64Array
+	dlaruv( seed, 3, x ); // $ExpectType Float64Array
 }
 
-// The compiler throws an error if the function is provided a first argument which is not a number...
+// The compiler throws an error if the function is provided a first argument which is not an Int32Array...
 {
-	const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	const X = new Float64Array( 3 );
-
-	dlaruv( '5', ISEED, X ); // $ExpectError
-	dlaruv( true, ISEED, X ); // $ExpectError
-	dlaruv( false, ISEED, X ); // $ExpectError
-	dlaruv( null, ISEED, X ); // $ExpectError
-	dlaruv( void 0, ISEED, X ); // $ExpectError
-	dlaruv( [], ISEED, X ); // $ExpectError
-	dlaruv( {}, ISEED, X ); // $ExpectError
-	dlaruv( ( x: number ): number => x, ISEED, X ); // $ExpectError
+	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 an Int32Array...
+// The compiler throws an error if the function is provided a second argument which is not a number...
 {
-	const X = new Float64Array( 3 );
-
-	dlaruv( 3, '5', X ); // $ExpectError
-	dlaruv( 3, 5, X ); // $ExpectError
-	dlaruv( 3, true, X ); // $ExpectError
-	dlaruv( 3, false, X ); // $ExpectError
-	dlaruv( 3, null, X ); // $ExpectError
-	dlaruv( 3, void 0, X ); // $ExpectError
-	dlaruv( 3, [], X ); // $ExpectError
-	dlaruv( 3, {}, X ); // $ExpectError
-	dlaruv( 3, ( x: number ): number => x, X ); // $ExpectError
+	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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-
-	dlaruv( 3, ISEED, '5' ); // $ExpectError
-	dlaruv( 3, ISEED, 5 ); // $ExpectError
-	dlaruv( 3, ISEED, true ); // $ExpectError
-	dlaruv( 3, ISEED, false ); // $ExpectError
-	dlaruv( 3, ISEED, null ); // $ExpectError
-	dlaruv( 3, ISEED, void 0 ); // $ExpectError
-	dlaruv( 3, ISEED, [] ); // $ExpectError
-	dlaruv( 3, ISEED, {} ); // $ExpectError
-	dlaruv( 3, ISEED, ( x: number ): number => x ); // $ExpectError
+	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 ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-	const X = new Float64Array( 3 );
+	const seed = new Int32Array( [ 0, 1, 2, 3 ] );
+	const x = new Float64Array( 3 );
 
 	dlaruv(); // $ExpectError
-	dlaruv( 3 ); // $ExpectError
-	dlaruv( 3, ISEED ); // $ExpectError
-	dlaruv( 3, ISEED, X, 10 ); // $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...
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
index 03c2ef30922d..7f78507d1ec2 100644
--- a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
@@ -28,22 +28,22 @@
 * var Float64Array = require( '@stdlib/array/float64' );
 * var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
 *
-* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv( 3, ISEED, X );
-* // X => <Float64Array>
+* dlaruv( seed, 3, x );
+* // x => <Float64Array>
 *
 * @example
 * var Int32Array = require( '@stdlib/array/int32' );
 * var Float64Array = require( '@stdlib/array/float64' );
 * var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
 *
-* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
-* var X = new Float64Array( 3 );
+* var seed = new Int32Array( [ 0, 1, 2, 3 ] );
+* var x = new Float64Array( 3 );
 *
-* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
-* // X => <Float64Array>
+* dlaruv.ndarray( 3, seed, 1, 0, x, 1, 0 );
+* // x => <Float64Array>
 */
 
 // MODULES //