fix: address review comments

Author: parthodas23

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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # snanmeankbn
 
-> Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+> Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 
 <section class="intro">
 
@@ -53,7 +53,7 @@ var snanmeankbn = require( '@stdlib/stats/strided/snanmeankbn' );
 
 #### snanmeankbn( N, x, strideX )
 
-Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 
 ```javascript
 var Float32Array = require( '@stdlib/array/float32' );
@@ -97,7 +97,7 @@ var v = snanmeankbn( 5, x1, 2 );
 
 #### snanmeankbn.ndarray( N, x, strideX, offsetX )
 
-Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm with alternative indexing semantics.
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm and alternative indexing semantics.
 
 ```javascript
 var Float32Array = require( '@stdlib/array/float32' );
@@ -198,7 +198,7 @@ console.log( v );
 
 #### stdlib_strided_snanmeankbn( N, \*X, strideX )
 
-Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 
 ```c
 const float x[] = { 1.0f, 2.0f, 3.0f, 0.0f/0.0f };
@@ -219,7 +219,7 @@ float stdlib_strided_snanmeankbn( const CBLAS_INT N, const float *X, const CBLAS
 
 #### stdlib_strided_snanmeankbn_ndarray( N, \*X, strideX, offsetX )
 
-Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm with alternative indexing semantics.
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm and alternative indexing semantics.
 
 ```c
 const float x[] = { 1.0f, 2.0f, 3.0f, 0.0f/0.0f };
@@ -291,14 +291,6 @@ int main( void ) {
 
 <section class="related">
 
-* * *
-
-## See Also
-
--   <span class="package-name">[`@stdlib/stats/strided/dmeankbn`][@stdlib/stats/strided/dmeankbn]</span><span class="delimiter">: </span><span class="description">calculate the arithmetic mean of a double-precision floating-point strided array using an improved Kahan–Babuška algorithm.</span>
--   <span class="package-name">[`@stdlib/stats/strided/smeankbn`][@stdlib/stats/strided/smeankbn]</span><span class="delimiter">: </span><span class="description">calculate the arithmetic mean of a single-precision floating-point strided array using an improved Kahan–Babuška algorithm.</span>
--   <span class="package-name">[`@stdlib/stats/strided/meankbn`][@stdlib/stats/strided/meankbn]</span><span class="delimiter">: </span><span class="description">calculate the arithmetic mean of a strided array using an improved Kahan–Babuška algorithm.</span>
-
 </section>
 
 <!-- /.related -->
@@ -315,12 +307,6 @@ int main( void ) {
 
 <!-- <related-links> -->
 
-[@stdlib/stats/strided/dmeankbn]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dmeankbn
-
-[@stdlib/stats/strided/smeankbn]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/smeankbn
-
-[@stdlib/stats/strided/meankbn]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/meankbn
-
 <!-- </related-links> -->
 
 </section>

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

@@ -1,7 +1,8 @@
 
 {{alias}}( N, x, strideX )
-    Computes the arithmetic mean of a single-precision floating-point strided array
-    ignoring NaN values and using an improved Kahan-Babuska algorithm.
+    Computes the arithmetic mean of a single-precision floating-point strided
+    array, ignoring `NaN` values and using an improved Kahan-Babuska
+    algorithm.
 
     The `N` and stride parameters determine which elements in the strided array
     are accessed at runtime.
@@ -50,7 +51,8 @@
 
 {{alias}}.ndarray( N, x, strideX, offsetX )
     Computes the arithmetic mean of a single-precision floating-point strided
-    array, ignoring `NaN` values and using alternative indexing semantics.
+    array, ignoring `NaN` values and using an improved Kahan-Babuska
+    algorithm and 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

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

@@ -19,11 +19,11 @@
 // TypeScript Version: 4.1
 
 /**
-* Interface describing  snanmeankbn`.
+* Interface describing `snanmeankbn`.
 */
 interface Routine {
 	/**
-	* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+	* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
@@ -41,7 +41,7 @@ interface Routine {
 	( N: number, x: Float32Array, strideX: number ): number;
 
 	/**
-	* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm with alternative indexing semantics.
+	* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
@@ -61,7 +61,7 @@ interface Routine {
 }
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 *
 * @param N - number of indexed elements
 * @param x - input array

lib/node_modules/@stdlib/stats/strided/snanmeankbn/include/stdlib/stats/strided/snanmeankbn.h

@@ -29,12 +29,12 @@ extern "C" {
 #endif
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 */
 float API_SUFFIX(stdlib_strided_snanmeankbn)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX );
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using alternative indexing semantics.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm and alternative indexing semantics.
 */
 float API_SUFFIX(stdlib_strided_snanmeankbn_ndarray)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 

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

@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* Compute the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Compute the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 *
 * @module @stdlib/stats/strided/snanmeankbn
 *

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

@@ -27,7 +27,15 @@ var snansumkbn = require( '@stdlib/blas/ext/base/snansumkbn' ).ndarray;
 // MAIN //
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
+*
+* ## Method
+*
+* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* -   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float32Array} x - input array
@@ -54,7 +62,6 @@ function snanmeankbn( N, x, strideX, offsetX ) {
 	if ( N <= 0 ) {
 		return NaN;
 	}
-
 	ix = offsetX;
 	for ( i = 0; i < N; i++ ) {
 		v = x[ ix ];
@@ -63,13 +70,10 @@ function snanmeankbn( N, x, strideX, offsetX ) {
 		}
 		ix += strideX;
 	}
-
 	if ( count === 0 ) {
 		return NaN;
 	}
-
 	sum = snansumkbn( N, x, strideX, offsetX );
-
 	return float64ToFloat32( sum / count );
 }
 

lib/node_modules/@stdlib/stats/strided/snanmeankbn/lib/ndarray.native.js

@@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float32Array} x - input array

lib/node_modules/@stdlib/stats/strided/snanmeankbn/lib/snanmeankbn.js

@@ -21,13 +21,21 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require( '@stdlib/stats/strided/snanmeankbn/lib/ndarray.js' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
+*
+* ## Method
+*
+* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* -   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float32Array} x - input array

lib/node_modules/@stdlib/stats/strided/snanmeankbn/lib/snanmeankbn.native.js

@@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array using an improved Kahan–Babuška algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float32Array} x - input array

lib/node_modules/@stdlib/stats/strided/snanmeankbn/src/main.c

@@ -22,7 +22,7 @@
 #include "stdlib/strided/base/stride2offset.h"
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm.
 *
 * @param N        number of indexed elements
 * @param X        input array
@@ -35,7 +35,7 @@ float API_SUFFIX(stdlib_strided_snanmeankbn)( const CBLAS_INT N, const float *X,
 }
 
 /**
-* Computes the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using an improved Kahan-Babuska algorithm.
+* Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using an improved Kahan-Babuska algorithm and alternative indexing semantics.
 *
 * @param N        number of indexed elements
 * @param X        input array