refactor: replace "minstd" with "pcg32"

---
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
    status: passed
  - 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: passed
  - task: lint_c_examples
    status: passed
  - task: lint_c_benchmarks
    status: passed
  - 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
---

Author: impawstarlight

lib/node_modules/@stdlib/random/base/pcg32/README.md

@@ -18,7 +18,7 @@ limitations under the License.
 
 -->
 
-# MINSTD
+# PCG32
 
 > A linear congruential pseudorandom number generator ([LCG][lcg]) based on Park and Miller.
 
@@ -27,33 +27,33 @@ limitations under the License.
 ## Usage
 
 ```javascript
-var minstd = require( '@stdlib/random/base/minstd' );
+var pcg32 = require( '@stdlib/random/base/pcg32' );
 ```
 
-#### minstd()
+#### pcg32()
 
 Returns a pseudorandom integer on the interval `[1, 2147483646]`.
 
 ```javascript
-var r = minstd();
+var r = pcg32();
 // returns <number>
 ```
 
-#### minstd.normalized()
+#### pcg32.normalized()
 
 Returns a pseudorandom number on the interval `[0,1)`.
 
 ```javascript
-var r = minstd.normalized();
+var r = pcg32.normalized();
 // returns <number>
 ```
 
-#### minstd.factory( \[options] )
+#### pcg32.factory( \[options] )
 
 Returns a linear congruential pseudorandom number generator ([LCG][lcg]).
 
 ```javascript
-var rand = minstd.factory();
+var rand = pcg32.factory();
 ```
 
 The function accepts the following `options`:
@@ -65,25 +65,25 @@ The function accepts the following `options`:
 By default, a random integer is used to seed the returned generator. To seed the generator, provide either an `integer` on the interval `[1, 2147483646]`
 
 ```javascript
-var rand = minstd.factory({
+var rand = pcg32.factory({
     'seed': 1234
 });
 
 var r = rand();
-// returns 20739838
+// returns 2557507945
 ```
 
 or, for arbitrary length seeds, an array-like `object` containing signed 32-bit integers
 
 ```javascript
 var Int32Array = require( '@stdlib/array/int32' );
 
-var rand = minstd.factory({
+var rand = pcg32.factory({
     'seed': new Int32Array( [ 1234 ] )
 });
 
 var r = rand();
-// returns 20739838
+// returns 2557507945
 ```
 
 To return a generator having a specific initial state, set the generator `state` option.
@@ -93,136 +93,136 @@ To return a generator having a specific initial state, set the generator `state`
 var r;
 var i;
 for ( i = 0; i < 1000; i++ ) {
-    r = minstd();
+    r = pcg32();
 }
 
-// Create a new PRNG initialized to the current state of `minstd`:
-var rand = minstd.factory({
-    'state': minstd.state
+// Create a new PRNG initialized to the current state of `pcg32`:
+var rand = pcg32.factory({
+    'state': pcg32.state
 });
 
 // Test that the generated pseudorandom numbers are the same:
-var bool = ( rand() === minstd() );
+var bool = ( rand() === pcg32() );
 // returns true
 ```
 
-#### minstd.NAME
+#### pcg32.NAME
 
 The generator name.
 
 ```javascript
-var str = minstd.NAME;
-// returns 'minstd'
+var str = pcg32.NAME;
+// returns 'pcg32'
 ```
 
-#### minstd.MIN
+#### pcg32.MIN
 
 Minimum possible value.
 
 ```javascript
-var min = minstd.MIN;
-// returns 1
+var min = pcg32.MIN;
+// returns 0
 ```
 
-#### minstd.MAX
+#### pcg32.MAX
 
 Maximum possible value.
 
 ```javascript
-var max = minstd.MAX;
-// returns 2147483646
+var max = pcg32.MAX;
+// returns 4294967295
 ```
 
-#### minstd.seed
+#### pcg32.seed
 
-The value used to seed `minstd()`.
+The value used to seed `pcg32()`.
 
 ```javascript
 // Generate pseudorandom values...
 var r;
 var i;
 for ( i = 0; i < 100; i++ ) {
-    r = minstd();
+    r = pcg32();
 }
 
 // Generate the same pseudorandom values...
-var rand = minstd.factory({
-    'seed': minstd.seed
+var rand = pcg32.factory({
+    'seed': pcg32.seed
 });
 for ( i = 0; i < 100; i++ ) {
     r = rand();
 }
 ```
 
-#### minstd.seedLength
+#### pcg32.seedLength
 
 Length of generator seed.
 
 ```javascript
-var len = minstd.seedLength;
+var len = pcg32.seedLength;
 // returns <number>
 ```
 
-#### minstd.state
+#### pcg32.state
 
 Writable property for getting and setting the generator state.
 
 ```javascript
-var r = minstd();
+var r = pcg32();
 // returns <number>
 
-r = minstd();
+r = pcg32();
 // returns <number>
 
 // ...
 
 // Get the current state:
-var state = minstd.state;
-// returns <Int32Array>
+var state = pcg32.state;
+// returns <Uint32Array>
 
-r = minstd();
+r = pcg32();
 // returns <number>
 
-r = minstd();
+r = pcg32();
 // returns <number>
 
 // Reset the state:
-minstd.state = state;
+pcg32.state = state;
 
 // Replay the last two pseudorandom numbers:
-r = minstd();
+r = pcg32();
 // returns <number>
 
-r = minstd();
+r = pcg32();
 // returns <number>
 
 // ...
 ```
 
-#### minstd.stateLength
+#### pcg32.stateLength
 
 Length of generator state.
 
 ```javascript
-var len = minstd.stateLength;
+var len = pcg32.stateLength;
 // returns <number>
 ```
 
-#### minstd.byteLength
+#### pcg32.byteLength
 
 Size (in bytes) of generator state.
 
 ```javascript
-var sz = minstd.byteLength;
+var sz = pcg32.byteLength;
 // returns <number>
 ```
 
-#### minstd.toJSON()
+#### pcg32.toJSON()
 
 Serializes the pseudorandom number generator as a JSON object.
 
 ```javascript
-var o = minstd.toJSON();
+var o = pcg32.toJSON();
 // returns { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }
 ```
 
@@ -250,26 +250,26 @@ var o = minstd.toJSON();
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var minstd = require( '@stdlib/random/base/minstd' );
+var pcg32 = require( '@stdlib/random/base/pcg32' );
 
 // Generate pseudorandom numbers...
 var i;
 for ( i = 0; i < 100; i++ ) {
-    console.log( minstd() );
+    console.log( pcg32() );
 }
 
 // Create a new pseudorandom number generator...
 var seed = 1234;
-var rand = minstd.factory({
+var rand = pcg32.factory({
     'seed': seed
 });
 for ( i = 0; i < 100; i++ ) {
     console.log( rand() );
 }
 
 // Create another pseudorandom number generator using a previous seed...
-rand = minstd.factory({
-    'seed': minstd.seed
+rand = pcg32.factory({
+    'seed': pcg32.seed
 });
 for ( i = 0; i < 100; i++ ) {
     console.log( rand() );
@@ -301,10 +301,10 @@ for ( i = 0; i < 100; i++ ) {
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/random/array/minstd`][@stdlib/random/array/minstd]</span><span class="delimiter">: </span><span class="description">create an array containing pseudorandom numbers generated using a linear congruential pseudorandom number generator (LCG).</span>
--   <span class="package-name">[`@stdlib/random/iter/minstd`][@stdlib/random/iter/minstd]</span><span class="delimiter">: </span><span class="description">create an iterator for a linear congruential pseudorandom number generator (LCG) based on Park and Miller.</span>
--   <span class="package-name">[`@stdlib/random/streams/minstd`][@stdlib/random/streams/minstd]</span><span class="delimiter">: </span><span class="description">create a readable stream for a linear congruential pseudorandom number generator (LCG) based on Park and Miller.</span>
--   <span class="package-name">[`@stdlib/random/base/minstd-shuffle`][@stdlib/random/base/minstd-shuffle]</span><span class="delimiter">: </span><span class="description">A linear congruential pseudorandom number generator (LCG) whose output is shuffled.</span>
+-   <span class="package-name">[`@stdlib/random/array/pcg32`][@stdlib/random/array/pcg32]</span><span class="delimiter">: </span><span class="description">create an array containing pseudorandom numbers generated using a linear congruential pseudorandom number generator (LCG).</span>
+-   <span class="package-name">[`@stdlib/random/iter/pcg32`][@stdlib/random/iter/pcg32]</span><span class="delimiter">: </span><span class="description">create an iterator for a linear congruential pseudorandom number generator (LCG) based on Park and Miller.</span>
+-   <span class="package-name">[`@stdlib/random/streams/pcg32`][@stdlib/random/streams/pcg32]</span><span class="delimiter">: </span><span class="description">create a readable stream for a linear congruential pseudorandom number generator (LCG) based on Park and Miller.</span>
+-   <span class="package-name">[`@stdlib/random/base/pcg32-shuffle`][@stdlib/random/base/pcg32-shuffle]</span><span class="delimiter">: </span><span class="description">A linear congruential pseudorandom number generator (LCG) whose output is shuffled.</span>
 -   <span class="package-name">[`@stdlib/random/base/mt19937`][@stdlib/random/base/mt19937]</span><span class="delimiter">: </span><span class="description">A 32-bit Mersenne Twister pseudorandom number generator.</span>
 -   <span class="package-name">[`@stdlib/random/base/randi`][@stdlib/random/base/randi]</span><span class="delimiter">: </span><span class="description">pseudorandom numbers having integer values.</span>
 
@@ -326,13 +326,13 @@ for ( i = 0; i < 100; i++ ) {
 
 <!-- <related-links> -->
 
-[@stdlib/random/array/minstd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/array/minstd
+[@stdlib/random/array/pcg32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/array/pcg32
 
-[@stdlib/random/iter/minstd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/iter/minstd
+[@stdlib/random/iter/pcg32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/iter/pcg32
 
-[@stdlib/random/streams/minstd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/streams/minstd
+[@stdlib/random/streams/pcg32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/streams/pcg32
 
-[@stdlib/random/base/minstd-shuffle]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/base/minstd-shuffle
+[@stdlib/random/base/pcg32-shuffle]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/base/pcg32-shuffle
 
 [@stdlib/random/base/mt19937]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/random/base/mt19937
 

lib/node_modules/@stdlib/random/base/pcg32/benchmark/benchmark.js

@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pkg = require( './../package.json' ).name;
-var minstd = require( './../lib' );
+var pcg32 = require( './../lib' );
 
 
 // MAIN //
@@ -34,7 +34,7 @@ bench( pkg, function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		z = minstd();
+		z = pcg32();
 		if ( isnan( z ) ) {
 			b.fail( 'should not return NaN' );
 		}
@@ -53,7 +53,7 @@ bench( pkg+':normalized', function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		z = minstd.normalized();
+		z = pcg32.normalized();
 		if ( isnan( z ) ) {
 			b.fail( 'should not return NaN' );
 		}