refactor: rename package xorshift to xorshift32

---
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/xorshift/README.md renamed to lib/node_modules/@stdlib/random/base/xorshift32/README.md

@@ -27,33 +27,33 @@ limitations under the License.
 ## Usage
 
 ```javascript
-var xorshift = require( '@stdlib/random/base/xorshift' );
+var xorshift32 = require( '@stdlib/random/base/xorshift32' );
 ```
 
-#### xorshift()
+#### xorshift32()
 
 Returns a pseudorandom integer on the interval `[1, 4294967295]`.
 
 ```javascript
-var r = xorshift();
+var r = xorshift32();
 // returns <number>
 ```
 
-#### xorshift.normalized()
+#### xorshift32.normalized()
 
 Returns a pseudorandom number on the interval `[0,1)`.
 
 ```javascript
-var r = xorshift.normalized();
+var r = xorshift32.normalized();
 // returns <number>
 ```
 
-#### xorshift.factory( \[options] )
+#### xorshift32.factory( \[options] )
 
 Returns a 32-bit [xorshift][] pseudorandom number generator.
 
 ```javascript
-var rand = xorshift.factory();
+var rand = xorshift32.factory();
 ```
 
 The function accepts the following `options`:
@@ -65,7 +65,7 @@ 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, 4294967295]`
 
 ```javascript
-var rand = xorshift.factory({
+var rand = xorshift32.factory({
     'seed': 1234
 });
 
@@ -78,7 +78,7 @@ or, for arbitrary length seeds, an array-like `object` containing unsigned 32-bi
 ```javascript
 var Uint32Array = require( '@stdlib/array/uint32' );
 
-var rand = xorshift.factory({
+var rand = xorshift32.factory({
     'seed': new Uint32Array( [ 1234 ] )
 });
 
@@ -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 = xorshift();
+    r = xorshift32();
 }
 
-// Create a new PRNG initialized to the current state of `xorshift`:
-var rand = xorshift.factory({
-    'state': xorshift.state
+// Create a new PRNG initialized to the current state of `xorshift32`:
+var rand = xorshift32.factory({
+    'state': xorshift32.state
 });
 
 // Test that the generated pseudorandom numbers are the same:
-var bool = ( rand() === xorshift() );
+var bool = ( rand() === xorshift32() );
 // returns true
 ```
 
-#### xorshift.NAME
+#### xorshift32.NAME
 
 The generator name.
 
 ```javascript
-var str = xorshift.NAME;
-// returns 'xorshift'
+var str = xorshift32.NAME;
+// returns 'xorshift32'
 ```
 
-#### xorshift.MIN
+#### xorshift32.MIN
 
 Minimum possible value.
 
 ```javascript
-var min = xorshift.MIN;
+var min = xorshift32.MIN;
 // returns 1
 ```
 
-#### xorshift.MAX
+#### xorshift32.MAX
 
 Maximum possible value.
 
 ```javascript
-var max = xorshift.MAX;
+var max = xorshift32.MAX;
 // returns 4294967295
 ```
 
-#### xorshift.seed
+#### xorshift32.seed
 
-The value used to seed `xorshift()`.
+The value used to seed `xorshift32()`.
 
 ```javascript
 // Generate pseudorandom values...
 var r;
 var i;
 for ( i = 0; i < 100; i++ ) {
-    r = xorshift();
+    r = xorshift32();
 }
 
 // Generate the same pseudorandom values...
-var rand = xorshift.factory({
-    'seed': xorshift.seed
+var rand = xorshift32.factory({
+    'seed': xorshift32.seed
 });
 for ( i = 0; i < 100; i++ ) {
     r = rand();
 }
 ```
 
-#### xorshift.seedLength
+#### xorshift32.seedLength
 
 Length of generator seed.
 
 ```javascript
-var len = xorshift.seedLength;
+var len = xorshift32.seedLength;
 // returns <number>
 ```
 
-#### xorshift.state
+#### xorshift32.state
 
 Writable property for getting and setting the generator state.
 
 ```javascript
-var r = xorshift();
+var r = xorshift32();
 // returns <number>
 
-r = xorshift();
+r = xorshift32();
 // returns <number>
 
 // ...
 
 // Get the current state:
-var state = xorshift.state;
+var state = xorshift32.state;
 // returns <Uint32Array>
 
-r = xorshift();
+r = xorshift32();
 // returns <number>
 
-r = xorshift();
+r = xorshift32();
 // returns <number>
 
 // Reset the state:
-xorshift.state = state;
+xorshift32.state = state;
 
 // Replay the last two pseudorandom numbers:
-r = xorshift();
+r = xorshift32();
 // returns <number>
 
-r = xorshift();
+r = xorshift32();
 // returns <number>
 
 // ...
 ```
 
-#### xorshift.stateLength
+#### xorshift32.stateLength
 
 Length of generator state.
 
 ```javascript
-var len = xorshift.stateLength;
+var len = xorshift32.stateLength;
 // returns <number>
 ```
 
-#### xorshift.byteLength
+#### xorshift32.byteLength
 
 Size (in bytes) of generator state.
 
 ```javascript
-var sz = xorshift.byteLength;
+var sz = xorshift32.byteLength;
 // returns <number>
 ```
 
-#### xorshift.toJSON()
+#### xorshift32.toJSON()
 
 Serializes the pseudorandom number generator as a JSON object.
 
 ```javascript
-var o = xorshift.toJSON();
+var o = xorshift32.toJSON();
 // returns { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }
 ```
 
@@ -250,26 +250,26 @@ var o = xorshift.toJSON();
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var xorshift = require( '@stdlib/random/base/xorshift' );
+var xorshift32 = require( '@stdlib/random/base/xorshift32' );
 
 // Generate pseudorandom numbers...
 var i;
 for ( i = 0; i < 100; i++ ) {
-    console.log( xorshift() );
+    console.log( xorshift32() );
 }
 
 // Create a new pseudorandom number generator...
 var seed = 1234;
-var rand = xorshift.factory({
+var rand = xorshift32.factory({
     'seed': seed
 });
 for ( i = 0; i < 100; i++ ) {
     console.log( rand() );
 }
 
 // Create another pseudorandom number generator using a previous seed...
-rand = xorshift.factory({
-    'seed': xorshift.seed
+rand = xorshift32.factory({
+    'seed': xorshift32.seed
 });
 for ( i = 0; i < 100; i++ ) {
     console.log( rand() );

lib/node_modules/@stdlib/random/base/xorshift/benchmark/benchmark.factory.js renamed to lib/node_modules/@stdlib/random/base/xorshift32/benchmark/benchmark.factory.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 xorshift = require( './../lib' );
+var xorshift32 = require( './../lib' );
 
 
 // MAIN //
@@ -34,7 +34,7 @@ bench( pkg, function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		z = xorshift();
+		z = xorshift32();
 		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 = xorshift.normalized();
+		z = xorshift32.normalized();
 		if ( isnan( z ) ) {
 			b.fail( 'should not return NaN' );
 		}