fix: apply suggestions from code review

---
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: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: missing_dependencies
  - 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: na
  - task: lint_license_headers
    status: passed
---

Author: headlessNode

lib/node_modules/@stdlib/blas/ext/base/smskrev/README.md

@@ -50,7 +50,7 @@ The function has the following parameters:
 -   **N**: number of indexed elements.
 -   **x**: input [`Float32Array`][@stdlib/array/float32].
 -   **strideX**: stride length for `x`.
--   **mask**: mask [`Uint8Array`][@stdlib/array/uint8]. If a `mask` array element is `0`, the corresponding element in `x` is considered unmasked and will participate in the reversal. If a `mask` array element is non-zero, the corresponding element in `x` is considered masked and the element will not participate in the reversal.
+-   **mask**: mask [`Uint8Array`][@stdlib/array/uint8]. If a `mask` array element is `0`, the corresponding element in `x` is considered valid and **included** in the reversal. If a `mask` array element is `1`, the corresponding element in `x` is considered invalid/missing and **excluded** from the reversal.
 -   **strideMask**: stride length for `mask`.
 
 The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to reverse every other element:
@@ -127,7 +127,6 @@ smskrev.ndarray( 3, x, 1, x.length-3, mask, 1, mask.length-3 );
 ## Notes
 
 -   If `N <= 0`, both functions return the strided array unchanged.
--   A swap is only performed when **both** elements in a pair are unmasked (i.e., their corresponding mask values are `0`). If either element is masked, neither element is modified.
 -   Where possible, one should "reverse" a strided array by negating its stride, which is an `O(1)` operation, in contrast to performing an in-place reversal, which is `O(N)`. However, in certain circumstances, this is not tenable, particularly when interfacing with libraries which assume and/or expect a specific memory layout (e.g., strided array elements arranged in memory in ascending order). In general, when working with strided arrays, only perform an in-place reversal when strictly necessary.
 
 </section>

lib/node_modules/@stdlib/blas/ext/base/smskrev/docs/repl.txt

@@ -11,9 +11,11 @@
 
     If `N <= 0`, the function returns `x` unchanged.
 
-    A mask value of `0` indicates that the corresponding element in `x`
-    participates in the reversal, while a non-zero mask value indicates that the
-    corresponding element should be skipped.
+    If a `mask` array element is `0`, the corresponding element in `x` is
+    considered valid and included in the reversal.
+
+    If a `mask` array element is `1`, the corresponding element in `x` is
+    considered invalid/missing and excluded from the reversal.
 
     Parameters
     ----------

lib/node_modules/@stdlib/blas/ext/base/smskrev/lib/ndarray.js

@@ -18,20 +18,10 @@
 
 'use strict';
 
-// MODULES //
-
-var floor = require( '@stdlib/math/base/special/floor' );
-
-
-// VARIABLES //
-
-var M = 3;
-
-
 // MAIN //
 
 /**
-* Reverses a single-precision floating-point strided array in-place according to a mask.
+* Reverses a single-precision floating-point strided array in-place according to a mask and using alternative indexing semantics.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float32Array} x - input array
@@ -53,80 +43,45 @@ var M = 3;
 * // x => <Float32Array>[ -3.0, -1.0, 0.0, -5.0, 4.0, 3.0, 1.0, -2.0 ]
 */
 function smskrev( N, x, strideX, offsetX, mask, strideMask, offsetMask ) {
+	var right;
+	var left;
 	var tmp;
 	var ix;
 	var iy;
 	var im;
 	var jm;
-	var m;
-	var n;
-	var i;
 
 	if ( N <= 0 ) {
 		return x;
 	}
-	n = floor( N/2 );
+	left = 0;
+	right = N - 1;
 	ix = offsetX;
+	iy = offsetX + ( (N-1) * strideX );
 	im = offsetMask;
-
-	// Use loop unrolling if the strides are equal to `1`...
-	if ( strideX === 1 && strideMask === 1 ) {
-		m = n % M;
-		iy = ix + N - 1;
-		jm = im + N - 1;
-
-		// If we have a remainder, run a clean-up loop...
-		if ( m > 0 ) {
-			for ( i = 0; i < m; i++ ) {
-				if ( mask[ im ] === 0 && mask[ jm ] === 0 ) {
-					tmp = x[ ix ];
-					x[ ix ] = x[ iy ];
-					x[ iy ] = tmp;
-				}
-				ix += 1;
-				im += 1;
-				iy -= 1;
-				jm -= 1;
-			}
-		}
-		if ( n < M ) {
-			return x;
+	jm = offsetMask + ( (N-1) * strideMask );
+	while ( left < right ) {
+		while ( left < right && mask[ im ] !== 0 ) {
+			left += 1;
+			ix += strideX;
+			im += strideMask;
 		}
-		for ( i = m; i < n; i += M ) {
-			if ( mask[ im ] === 0 && mask[ jm ] === 0 ) {
-				tmp = x[ ix ];
-				x[ ix ] = x[ iy ];
-				x[ iy ] = tmp;
-			}
-			if ( mask[ im+1 ] === 0 && mask[ jm-1 ] === 0 ) {
-				tmp = x[ ix+1 ];
-				x[ ix+1 ] = x[ iy-1 ];
-				x[ iy-1 ] = tmp;
-			}
-			if ( mask[ im+2 ] === 0 && mask[ jm-2 ] === 0 ) {
-				tmp = x[ ix+2 ];
-				x[ ix+2 ] = x[ iy-2 ];
-				x[ iy-2 ] = tmp;
-			}
-			ix += M;
-			im += M;
-			iy -= M;
-			jm -= M;
+		while ( right > left && mask[ jm ] !== 0 ) {
+			right -= 1;
+			iy -= strideX;
+			jm -= strideMask;
 		}
-		return x;
-	}
-	iy = ix + ( (N-1) * strideX );
-	jm = im + ( (N-1) * strideMask );
-	for ( i = 0; i < n; i++ ) {
-		if ( mask[ im ] === 0 && mask[ jm ] === 0 ) {
+		if ( left < right ) {
 			tmp = x[ ix ];
 			x[ ix ] = x[ iy ];
 			x[ iy ] = tmp;
+			left += 1;
+			ix += strideX;
+			im += strideMask;
+			right -= 1;
+			iy -= strideX;
+			jm -= strideMask;
 		}
-		ix += strideX;
-		im += strideMask;
-		iy -= strideX;
-		jm -= strideMask;
 	}
 	return x;
 }

lib/node_modules/@stdlib/blas/ext/base/smskrev/src/main.c

@@ -48,80 +48,45 @@ void API_SUFFIX(stdlib_strided_smskrev)( const CBLAS_INT N, float *X, const CBLA
 * @param offsetMask  starting index for Mask
 */
 void API_SUFFIX(stdlib_strided_smskrev_ndarray)( const CBLAS_INT N, float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const uint8_t *Mask, const CBLAS_INT strideMask, const CBLAS_INT offsetMask ) {
+	CBLAS_INT right;
+	CBLAS_INT left;
 	CBLAS_INT ix;
 	CBLAS_INT iy;
 	CBLAS_INT im;
 	CBLAS_INT jm;
-	CBLAS_INT m;
-	CBLAS_INT n;
-	CBLAS_INT i;
 	float tmp;
 
 	if ( N <= 0 ) {
 		return;
 	}
-	n = N / 2;
+	left = 0;
+	right = N - 1;
 	ix = offsetX;
+	iy = offsetX + ( (N-1) * strideX );
 	im = offsetMask;
-
-	// Use loop unrolling if the strides are equal to `1`...
-	if ( strideX == 1 && strideMask == 1 ) {
-		m = n % 3;
-		iy = ix + N - 1;
-		jm = im + N - 1;
-
-		// If we have a remainder, run a clean-up loop...
-		if ( m > 0 ) {
-			for ( i = 0; i < m; i++ ) {
-				if ( Mask[ im ] == 0 && Mask[ jm ] == 0 ) {
-					tmp = X[ ix ];
-					X[ ix ] = X[ iy ];
-					X[ iy ] = tmp;
-				}
-				ix += 1;
-				im += 1;
-				iy -= 1;
-				jm -= 1;
-			}
-		}
-		if ( n < 3 ) {
-			return;
+	jm = offsetMask + ( (N-1) * strideMask );
+	while ( left < right ) {
+		while ( left < right && Mask[ im ] != 0 ) {
+			left += 1;
+			ix += strideX;
+			im += strideMask;
 		}
-		for ( i = m; i < n; i += 3 ) {
-			if ( Mask[ im ] == 0 && Mask[ jm ] == 0 ) {
-				tmp = X[ ix ];
-				X[ ix ] = X[ iy ];
-				X[ iy ] = tmp;
-			}
-			if ( Mask[ im+1 ] == 0 && Mask[ jm-1 ] == 0 ) {
-				tmp = X[ ix+1 ];
-				X[ ix+1 ] = X[ iy-1 ];
-				X[ iy-1 ] = tmp;
-			}
-			if ( Mask[ im+2 ] == 0 && Mask[ jm-2 ] == 0 ) {
-				tmp = X[ ix+2 ];
-				X[ ix+2 ] = X[ iy-2 ];
-				X[ iy-2 ] = tmp;
-			}
-			ix += 3;
-			im += 3;
-			iy -= 3;
-			jm -= 3;
+		while ( right > left && Mask[ jm ] != 0 ) {
+			right -= 1;
+			iy -= strideX;
+			jm -= strideMask;
 		}
-		return;
-	}
-	iy = ix + ( (N-1) * strideX );
-	jm = im + ( (N-1) * strideMask );
-	for ( i = 0; i < n; i++ ) {
-		if ( Mask[ im ] == 0 && Mask[ jm ] == 0 ) {
+		if ( left < right ) {
 			tmp = X[ ix ];
 			X[ ix ] = X[ iy ];
 			X[ iy ] = tmp;
+			left += 1;
+			ix += strideX;
+			im += strideMask;
+			right -= 1;
+			iy -= strideX;
+			jm -= strideMask;
 		}
-		ix += strideX;
-		im += strideMask;
-		iy -= strideX;
-		jm -= strideMask;
 	}
 	return;
 }

lib/node_modules/@stdlib/blas/ext/base/smskrev/test/test.ndarray.js

@@ -137,14 +137,23 @@ tape( 'the function supports masking', function test( t ) {
 	t.end();
 });
 
-tape( 'the function skips pairs where either element is masked', function test( t ) {
+tape( 'the function excludes masked elements from the reversal', function test( t ) {
 	var expected;
 	var mask;
 	var x;
 
+	// Mask the first element:
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );
-	mask = new Uint8Array( [ 1, 0, 0, 1 ] );
-	expected = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] );
+	mask = new Uint8Array( [ 1, 0, 0, 0 ] );
+	expected = new Float32Array( [ 1.0, 4.0, 3.0, 2.0 ] );
+
+	smskrev( x.length, x, 1, 0, mask, 1, 0 );
+	t.deepEqual( x, expected, 'returns expected value' );
+
+	// Mask the last element:
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	mask = new Uint8Array( [ 0, 0, 0, 1 ] );
+	expected = new Float32Array( [ 3.0, 2.0, 1.0, 4.0 ] );
 
 	smskrev( x.length, x, 1, 0, mask, 1, 0 );
 	t.deepEqual( x, expected, 'returns expected value' );
@@ -264,6 +273,21 @@ tape( 'the function supports specifying a negative stride', function test( t ) {
 	t.end();
 });
 
+tape( 'the function supports specifying a mask stride', function test( t ) {
+	var expected;
+	var mask;
+	var x;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
+	mask = new Uint8Array( [ 0, 0, 0, 0, 1 ] );
+	expected = new Float32Array( [ 2.0, 1.0, 3.0 ] );
+
+	smskrev( x.length, x, 1, 0, mask, 2, 0 );
+	t.deepEqual( x, expected, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports specifying an offset', function test( t ) {
 	var expected;
 	var mask;

lib/node_modules/@stdlib/blas/ext/base/smskrev/test/test.ndarray.native.js

@@ -146,14 +146,23 @@ tape( 'the function supports masking', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function skips pairs where either element is masked', opts, function test( t ) {
+tape( 'the function excludes masked elements from the reversal', opts, function test( t ) {
 	var expected;
 	var mask;
 	var x;
 
+	// Mask the first element:
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );
-	mask = new Uint8Array( [ 1, 0, 0, 1 ] );
-	expected = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] );
+	mask = new Uint8Array( [ 1, 0, 0, 0 ] );
+	expected = new Float32Array( [ 1.0, 4.0, 3.0, 2.0 ] );
+
+	smskrev( x.length, x, 1, 0, mask, 1, 0 );
+	t.deepEqual( x, expected, 'returns expected value' );
+
+	// Mask the last element:
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	mask = new Uint8Array( [ 0, 0, 0, 1 ] );
+	expected = new Float32Array( [ 3.0, 2.0, 1.0, 4.0 ] );
 
 	smskrev( x.length, x, 1, 0, mask, 1, 0 );
 	t.deepEqual( x, expected, 'returns expected value' );
@@ -273,6 +282,21 @@ tape( 'the function supports specifying a negative stride', opts, function test(
 	t.end();
 });
 
+tape( 'the function supports specifying a mask stride', opts, function test( t ) {
+	var expected;
+	var mask;
+	var x;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
+	mask = new Uint8Array( [ 0, 0, 0, 0, 1 ] );
+	expected = new Float32Array( [ 2.0, 1.0, 3.0 ] );
+
+	smskrev( x.length, x, 1, 0, mask, 2, 0 );
+	t.deepEqual( x, expected, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports specifying an offset', opts, function test( t ) {
 	var expected;
 	var mask;