refactor: apply suggested changes

Author: gururaj1512

lib/node_modules/@stdlib/stats/strided/ztest2/README.md

@@ -22,7 +22,7 @@ limitations under the License.
 
 # ztest2
 
-> Compute a two-sample Z-test for a strided array.
+> Compute a two-sample Z-test.
 
 <section class="intro">
 
@@ -48,7 +48,7 @@ var ztest2 = require( '@stdlib/stats/strided/ztest2' );
 
 #### ztest2( NX, NY, alternative, alpha, diff, sigmax, sigmay, x, strideX, y, strideY, out )
 
-Computes a two-sample Z-test for a strided array.
+Computes a two-sample Z-test.
 
 ```javascript
 var Results = require( '@stdlib/stats/base/ztest/two-sample/results/float64' );
@@ -119,7 +119,7 @@ var bool = ( out === results );
 
 #### ztest2.ndarray( NX, NY, alternative, alpha, diff, sigmax, sigmay, x, strideX, offsetX, y, strideY, offsetY, out )
 
-Computes a two-sample Z-test for a strided array using alternative indexing semantics.
+Computes a two-sample Z-test using alternative indexing semantics.
 
 ```javascript
 var Results = require( '@stdlib/stats/base/ztest/two-sample/results/float64' );
@@ -140,7 +140,7 @@ The function has the following additional parameters:
 -   **offsetX**: starting index for `x`.
 -   **offsetY**: starting index for `y`.
 
-While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to perform a two-sample Z-test over every other element in `x` and `y` starting from the second element
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, offset parameters support indexing semantics based on starting indices. For example, to perform a two-sample Z-test over every other element in `x` and `y` starting from the second element
 
 ```javascript
 var Results = require( '@stdlib/stats/base/ztest/two-sample/results/float64' );
@@ -166,7 +166,7 @@ var bool = ( out === results );
 
 -   As a general rule of thumb, a Z-test is most reliable when `N >= 50`. For smaller sample sizes or when the standard deviation is unknown, prefer a t-test.
 -   Both functions support array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]).
--   Depending on the environment, the typed versions ([`dztest2`][@stdlib/stats/strided/dztest2], [`sztest2`][@stdlib/stats/strided/sztest2], etc.) are likely to be significantly more performant.
+<!-- -   Depending on the environment, the typed versions ([`dztest2`][@stdlib/stats/strided/dztest2], [`sztest2`][@stdlib/stats/strided/sztest2], etc.) are likely to be significantly more performant. -->
 
 </section>
 
@@ -227,9 +227,9 @@ console.log( out.toString() );
 
 [@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
 
-[@stdlib/stats/strided/dztest2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dztest
+<!-- [@stdlib/stats/strided/dztest2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dztest -->
 
-[@stdlib/stats/strided/sztest2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/sztest
+<!-- [@stdlib/stats/strided/sztest2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/sztest -->
 
 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 

lib/node_modules/@stdlib/stats/strided/ztest2/benchmark/benchmark.ndarray.js

@@ -97,7 +97,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+':len='+len, f );
+		bench( pkg+':ndarray:len='+len, f );
 	}
 }
 

lib/node_modules/@stdlib/stats/strided/ztest2/docs/repl.txt

@@ -1,6 +1,6 @@
 
-{{alias}}( NX, NY, alternative, alpha, diff, sigmax, sigmay, x, strideX, y, strideY, out )
-    Computes a two-sample Z-test for a strided array.
+{{alias}}( NX, NY, alt, alpha, diff, sigmax, sigmay, x, sx, y, sy, out )
+    Computes a two-sample Z-test.
 
     The `N` and stride parameters determine which elements in the strided array
     are accessed at runtime.
@@ -19,9 +19,9 @@
     alternative: string
         Alternative hypothesis. Must be one of the following:
 
-        - two-sided: `x` has same mean as `y`
-        - greater: `x` has larger mean than `y`
-        - less: `x` has smaller mean than `y`
+        - two-sided: `x` has same mean as `y`.
+        - greater: `x` has larger mean than `y`.
+        - less: `x` has smaller mean than `y`.
 
     alpha: number
         Significance level.
@@ -67,13 +67,12 @@
     > res.toString()
 
 
-{{alias}}.ndarray( NX, NY, alternative, alpha, diff, sigmax, sigmay, x, strideX, offsetX, y, strideY, offsetY, out )
-    Computes a two-sample Z-test for a strided array using alternative indexing
-    semantics.
+{{alias}}.ndarray( NX, NY, alt, alpha, diff, sigmax, sigmay, x, sx, ox, y, sy, oy, out )
+    Computes a two-sample Z-test using alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
-    buffer, the offset parameter supports indexing semantics based on a starting
-    index.
+    buffer, offset parameters support indexing semantics based on starting
+    indices.
 
     Parameters
     ----------
@@ -86,9 +85,9 @@
     alternative: string
         Alternative hypothesis. Must be one of the following:
 
-        - two-sided: `x` has same mean as `y`
-        - greater: `x` has larger mean than `y`
-        - less: `x` has smaller mean than `y`
+        - two-sided: `x` has same mean as `y`.
+        - greater: `x` has larger mean than `y`.
+        - less: `x` has smaller mean than `y`.
 
     alpha: number
         Significance level.

lib/node_modules/@stdlib/stats/strided/ztest2/docs/types/index.d.ts

@@ -96,7 +96,7 @@ interface BaseResults {
 	ci: Float64Array;
 
 	/**
-	* Difference in means under the null hypothesis
+	* Difference in means under the null hypothesis.
 	*/
 	nullValue: number;
 
@@ -131,7 +131,7 @@ interface Results extends BaseResults {
 */
 interface Routine {
 	/**
-	* Computes a two-sample Z-test for a strided array.
+	* Computes a two-sample Z-test.
 	*
 	* @param NX - number of indexed elements in `x`
 	* @param NY - number of indexed elements in `y`
@@ -163,7 +163,7 @@ interface Routine {
 	<T extends BaseResults>( NX: number, NY: number, alternative: Alternative, alpha: number, diff: number, sigmax: number, sigmay: number, x: InputArray, strideX: number, y: InputArray, strideY: number, out: T ): Results;
 
 	/**
-	* Computes a two-sample Z-test for a strided array using alternative indexing semantics.
+	* Computes a two-sample Z-test using alternative indexing semantics.
 	*
 	* @param NX - number of indexed elements in `x`
 	* @param NY - number of indexed elements in `y`
@@ -198,7 +198,7 @@ interface Routine {
 }
 
 /**
-* Computes a two-sample Z-test for a strided array.
+* Computes a two-sample Z-test.
 *
 * @param NX - number of indexed elements in `x`
 * @param NY - number of indexed elements in `y`

lib/node_modules/@stdlib/stats/strided/ztest2/docs/types/test.ts

@@ -137,7 +137,7 @@ import ztest2 = require( './index' );
 	ztest2( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, ( x: number ): number => x, x, 1, y, 1, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided a eigth argument which is not an array-like object...
+// The compiler throws an error if the function is provided an eighth argument which is not an array-like object...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -182,7 +182,7 @@ import ztest2 = require( './index' );
 	ztest2( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, 1.0, x, 1, ( x: number ): number => x, 1, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided a eleventh argument which is not a number...
+// The compiler throws an error if the function is provided an eleventh argument which is not a number...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -197,7 +197,7 @@ import ztest2 = require( './index' );
 	ztest2( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, 1.0, x, 1, y, ( x: number ): number => x, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided an twelfth argument which is not a results object...
+// The compiler throws an error if the function is provided a twelfth argument which is not a results object...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -348,7 +348,7 @@ import ztest2 = require( './index' );
 	ztest2.ndarray( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, ( x: number ): number => x, x, 1, 0, y, 1, 0, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the `ndarray` method is provided a eigth argument which is not an array-like object...
+// The compiler throws an error if the `ndarray` method is provided an eigth argument which is not an array-like object...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -378,7 +378,7 @@ import ztest2 = require( './index' );
 	ztest2.ndarray( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, 1.0, x, ( x: number ): number => x, 0, y, 1, 0, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the `ndarray` method is provided an tenth argument which is not a number...
+// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -393,7 +393,7 @@ import ztest2 = require( './index' );
 	ztest2.ndarray( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, 1.0, x, 1, ( x: number ): number => x, y, 1, 0, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the `ndarray` method is provided a eleventh argument which is not an array-like object...
+// The compiler throws an error if the `ndarray` method is provided an eleventh argument which is not an array-like object...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
@@ -423,7 +423,7 @@ import ztest2 = require( './index' );
 	ztest2.ndarray( x.length, y.length, 'two-sided', 0.05, 0.0, 1.0, 1.0, x, 1, 0, y, ( x: number ): number => x, 0, new Float64Results() ); // $ExpectError
 }
 
-// The compiler throws an error if the `ndarray` method is provided an thirteenth argument which is not a number...
+// The compiler throws an error if the `ndarray` method is provided a thirteenth argument which is not a number...
 {
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );

lib/node_modules/@stdlib/stats/strided/ztest2/lib/index.js

@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* Compute a two-sample Z-test for a strided array.
+* Compute a two-sample Z-test.
 *
 * @module @stdlib/stats/strided/ztest2
 *

lib/node_modules/@stdlib/stats/strided/ztest2/lib/main.js

@@ -27,7 +27,7 @@ var ndarray = require( './ndarray.js' );
 // MAIN //
 
 /**
-* Computes a two-sample Z-test for a strided array.
+* Computes a two-sample Z-test.
 *
 * @param {PositiveInteger} NX - number of indexed elements in `x`
 * @param {PositiveInteger} NY - number of indexed elements in `y`

lib/node_modules/@stdlib/stats/strided/ztest2/lib/ndarray.js

@@ -44,7 +44,7 @@ var WORKSPACE = new Float64Array( 2 );
 // MAIN //
 
 /**
-* Computes a two-sample Z-test for a strided array using alternative indexing semantics.
+* Computes a two-sample Z-test using alternative indexing semantics.
 *
 * @param {PositiveInteger} NX - number of indexed elements in `x`
 * @param {PositiveInteger} NY - number of indexed elements in `y`
@@ -117,11 +117,11 @@ function ztest2( NX, NY, alternative, alpha, diff, sigmax, sigmay, x, strideX, o
 	yvar = sigmay * sigmay;
 	stderr = sqrt( ( xvar / NX ) + ( yvar / NY ) );
 
-	// Compute the arithmetic mean of the input array:
+	// Compute the arithmetic means of the input arrays:
 	xmean = mean( NX, x, strideX, offsetX );
 	ymean = mean( NY, y, strideY, offsetY );
 
-	// Compute the test statistic (i.e., the z-score, which is the distance of the sample mean from the population mean in units of standard error):
+	// Compute the test statistic (i.e., the z-score, which is the standardized difference between the sample means of x and y, adjusted by the hypothesized difference, in units of the standard error):
 	stat = ( xmean - ymean - diff ) / stderr;
 
 	// Compute the p-value and confidence interval...

lib/node_modules/@stdlib/stats/strided/ztest2/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/stats/strided/ztest2",
   "version": "0.0.0",
-  "description": "Compute a two-sample Z-test for a strided array.",
+  "description": "Compute a two-sample Z-test.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",

lib/node_modules/@stdlib/stats/strided/ztest2/test/test.main.js

@@ -46,15 +46,15 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function performs a two-sample Z-test over a strided array (alternative=two-sided)', function test( t ) {
+tape( 'the function performs a two-sample Z-test (alternative=two-sided)', function test( t ) {
 	var results;
 	var out;
 	var x;
 	var y;
 
 	results = new Float64Results();
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -80,7 +80,7 @@ tape( 'the function performs a two-sample Z-test over a strided array (alternati
 	t.strictEqual( isfinite( out.ci[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( isfinite( out.ci[ 1 ] ), true, 'returns expected value' );
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 4.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -100,15 +100,15 @@ tape( 'the function performs a two-sample Z-test over a strided array (alternati
 	t.end();
 });
 
-tape( 'the function performs a two-sample Z-test over a strided array (alternative=greater)', function test( t ) {
+tape( 'the function performs a two-sample Z-test (alternative=greater)', function test( t ) {
 	var results;
 	var out;
 	var x;
 	var y;
 
 	results = new Float64Results();
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -125,7 +125,7 @@ tape( 'the function performs a two-sample Z-test over a strided array (alternati
 	t.strictEqual( isfinite( out.ci[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( out.ci[ 1 ], PINF, 'returns expected value' );
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -145,15 +145,15 @@ tape( 'the function performs a two-sample Z-test over a strided array (alternati
 	t.end();
 });
 
-tape( 'the function performs a two-sample Z-test over a strided array (alternative=less)', function test( t ) {
+tape( 'the function performs a two-sample Z-test (alternative=less)', function test( t ) {
 	var results;
 	var out;
 	var x;
 	var y;
 
 	results = new Float64Results();
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 2.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -170,7 +170,7 @@ tape( 'the function performs a two-sample Z-test over a strided array (alternati
 	t.strictEqual( out.ci[ 0 ], NINF, 'returns expected value' );
 	t.strictEqual( isfinite( out.ci[ 1 ] ), true, 'returns expected value' );
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( 10000, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -245,7 +245,7 @@ tape( 'the function supports a stride parameter', function test( t ) {
 	N = 10000;
 	results = new Float64Results();
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( N*2, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -265,7 +265,7 @@ tape( 'the function supports a stride parameter', function test( t ) {
 	t.strictEqual( isfinite( out.ci[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( isfinite( out.ci[ 1 ] ), true, 'returns expected value' );
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( N*2, 4.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -298,7 +298,7 @@ tape( 'the function supports a negative stride parameter', function test( t ) {
 	N = 10000;
 	results = new Float64Results();
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( N*2, 0.0, 1.0, {
 		'dtype': 'generic'
 	});
@@ -318,7 +318,7 @@ tape( 'the function supports a negative stride parameter', function test( t ) {
 	t.strictEqual( isfinite( out.ci[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( isfinite( out.ci[ 1 ] ), true, 'returns expected value' );
 
-	// Generate an array with a sufficiently large sample size to effectively guarantee expected results:
+	// Generate arrays with a sufficiently large sample size to effectively guarantee expected results:
 	x = normal( N*2, 100.0, 1.0, {
 		'dtype': 'generic'
 	});