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

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/README.md

@@ -30,11 +30,9 @@ limitations under the License.
 var dcartesianProduct = require( '@stdlib/blas/ext/base/dcartesian-product' );
 ```
 
-<!-- lint disable maximum-heading-length -->
+#### dcartesianProduct( M, N, x, strideX, y, strideY, out, LDO )
 
-#### dcartesianProduct( M, N, x, strideX, y, strideY, out, strideOut1, strideOut2 )
-
-Computes the Cartesian product for a double-precision floating-point strided array.
+Computes the Cartesian product for two double-precision floating-point strided arrays.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -44,7 +42,7 @@ var y = new Float64Array( [ 3.0, 4.0 ] );
 var out = new Float64Array( 8 );
 
 // Compute the Cartesian product:
-dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2, 1 );
+dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2 );
 // out => <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 ```
 
@@ -57,10 +55,9 @@ The function has the following parameters:
 -   **y**: input [`Float64Array`][@stdlib/array/float64].
 -   **strideY**: stride length for `y`.
 -   **out**: output [`Float64Array`][@stdlib/array/float64].
--   **strideOut1**: stride length between consecutive output pairs.
--   **strideOut2**: stride length between the two elements of each output pair.
+-   **LDO**: stride of the leading dimension of `out`.
 
-The `N`, `M` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the Cartesian square of every other element:
+The `M`, `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the Cartesian square of every other element:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -70,7 +67,7 @@ var y = new Float64Array( [ 3.0, 0.0, 4.0, 0.0 ] );
 var out = new Float64Array( 8 );
 
 // Compute the Cartesian product:
-dcartesianProduct( 2, 2, x, 2, y, 2, out, 2, 1 );
+dcartesianProduct( 2, 2, x, 2, y, 2, out, 2 );
 // out => <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 ```
 
@@ -90,7 +87,7 @@ var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd
 var out = new Float64Array( 8 );
 
 // Compute the Cartesian product:
-dcartesianProduct( 2, 2, x1, 1, y1, 1, out, 2, 1 );
+dcartesianProduct( 2, 2, x1, 1, y1, 1, out, 2 );
 // out => <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 ```
 
@@ -100,7 +97,7 @@ dcartesianProduct( 2, 2, x1, 1, y1, 1, out, 2, 1 );
 
 <!--lint enable maximum-heading-length-->
 
-Computes the Cartesian product for a double-precision floating-point strided array using alternative indexing semantics.
+Computes the Cartesian product for two double-precision floating-point strided arrays using alternative indexing semantics.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -118,6 +115,8 @@ The function has the following additional parameters:
 
 -   **offsetX**: starting index for `x`.
 -   **offsetY**: starting index for `y`.
+-   **strideOut1**: stride length of the first dimension of `out`.
+-   **strideOut2**: stride length of the second dimension of `out`.
 -   **offsetOut**: starting index for `out`.
 
 While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to access only the last two elements:
@@ -142,7 +141,7 @@ dcartesianProduct.ndarray( 2, 2, x, 1, 2, y, 1, 2, out, 2, 1, 0 );
 
 ## Notes
 
--   For an input array `x` of length `N`, the output array `out` must contain at least `M*N` pairs.
+-   For an input array `x` of length `M` and an input array `y` of length `N`, the output array `out` must contain at least `M*N` pairs.
 -   If `N <= 0` or `M <= 0`, both functions return `out` unchanged.
 
 </section>
@@ -175,7 +174,7 @@ console.log( y );
 var out = new Float64Array( M * N * 2 );
 
 // Compute the Cartesian product:
-dcartesianProduct( M, N, x, 1, y, 1, out, 2, 1 );
+dcartesianProduct( M, N, x, 1, y, 1, out, 2 );
 console.log( out );
 ```
 
@@ -209,20 +208,16 @@ console.log( out );
 #include "stdlib/blas/ext/base/dcartesianproduct.h"
 ```
 
-<!--lint disable maximum-heading-length-->
-
-#### stdlib_strided_dcartesian_product( M, N, \*X, strideX, \*Y, strideY, \*Out, strideOut1, strideOut2 )
-
-<!--lint enable maximum-heading-length-->
+#### stdlib_strided_dcartesian_product( M, N, \*X, strideX, \*Y, strideY, \*Out, LDO )
 
-Computes the Cartesian product for a double-precision floating-point strided array.
+Computes the Cartesian product for two double-precision floating-point strided arrays.
 
 ```c
 const double x[] = { 1.0, 2.0 };
 const double y[] = { 3.0, 4.0 };
 double out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 
-stdlib_strided_dcartesian_product( 2, 2, x, 1, y, 1, out, 2, 1 );
+stdlib_strided_dcartesian_product( 2, 2, x, 1, y, 1, out, 2 );
 ```
 
 The function accepts the following arguments:
@@ -234,11 +229,10 @@ The function accepts the following arguments:
 -   **Y**: `[in] double*` input array.
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 -   **Out**: `[out] double*` output array.
--   **strideOut1**: `[in] CBLAS_INT` stride length between consecutive output pairs.
--   **strideOut2**: `[in] CBLAS_INT` stride length between elements of each output pair.
+-   **LDO**: `[in] CBLAS_INT` stride of the leading dimension of `Out`.
 
 ```c
-void stdlib_strided_dcartesian_product( const CBLAS_INT M, const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const double *Y, const CBLAS_INT strideY, double *Out, const CBLAS_INT strideOut1, const CBLAS_INT strideOut2 );
+void stdlib_strided_dcartesian_product( const CBLAS_INT M, const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const double *Y, const CBLAS_INT strideY, double *Out, const CBLAS_INT LDO );
 ```
 
 <!--lint disable maximum-heading-length-->
@@ -247,7 +241,7 @@ void stdlib_strided_dcartesian_product( const CBLAS_INT M, const CBLAS_INT N, co
 
 <!--lint enable maximum-heading-length-->
 
-Computes the Cartesian product for a double-precision floating-point strided array using alternative indexing semantics.
+Computes the Cartesian product for two double-precision floating-point strided arrays using alternative indexing semantics.
 
 ```c
 const double x[] = { 1.0, 2.0 };
@@ -268,8 +262,8 @@ The function accepts the following arguments:
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 -   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
 -   **Out**: `[out] double*` output array.
--   **strideOut1**: `[in] CBLAS_INT` stride length between consecutive output pairs.
--   **strideOut2**: `[in] CBLAS_INT` stride length between elements of each output pair.
+-   **strideOut1**: `[in] CBLAS_INT` stride length of the first dimension of `Out`.
+-   **strideOut2**: `[in] CBLAS_INT` stride length of the second dimension of `Out`.
 -   **offsetOut**: `[in] CBLAS_INT` starting index for `Out`.
 
 ```c
@@ -313,11 +307,10 @@ int main( void ) {
     // Specify strides:
     const int strideX = 1;
     const int strideY = 1;
-    const int strideOut1 = 2;
-    const int strideOut2 = 1;
+    const int LDO = 2;
 
     // Compute the Cartesian product:
-    stdlib_strided_dcartesian_product( M, N, X, strideX, Y, strideY, out, strideOut1, strideOut2 );
+    stdlib_strided_dcartesian_product( M, N, X, strideX, Y, strideY, out, LDO );
 
     // Print the result:
     for ( int i = 0; i < M*N; i++ ) {

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/benchmark/benchmark.js

@@ -68,7 +68,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2, 1 );
+			z = dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2 );
 			if ( isnan( z[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/benchmark/benchmark.native.js

@@ -73,7 +73,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2, 1 );
+			z = dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2 );
 			if ( isnan( z[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/benchmark/c/benchmark.length.c

@@ -111,7 +111,7 @@ static double benchmark1( int iterations, int len ) {
 	}
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		stdlib_strided_dcartesian_product( len, len, x, 1, y, 1, out, 2, 1 );
+		stdlib_strided_dcartesian_product( len, len, x, 1, y, 1, out, 2 );
 		if ( out[ 0 ] != out[ 0 ] ) {
 			printf( "should not return NaN\n" );
 			break;

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/docs/repl.txt

@@ -1,5 +1,5 @@
 
-{{alias}}( M, N, x, strideX, y, strideY, out, strideOut1, strideOut2 )
+{{alias}}( M, N, x, strideX, y, strideY, out, LDO )
     Computes the Cartesian product for two double-precision floating-point
     strided arrays.
 
@@ -31,11 +31,8 @@
     out: Float64Array
         Output array.
 
-    strideOut1: integer
-        Stride length between consecutive output pairs.
-
-    strideOut2: integer
-        Stride length between elements of each output pair.
+    LDO: integer
+        Stride of the leading dimension of `out`.
 
     Returns
     -------
@@ -48,18 +45,18 @@
     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0 ] );
     > var y = new {{alias:@stdlib/array/float64}}( [ 3.0, 4.0 ] );
     > var out = new {{alias:@stdlib/array/float64}}( 8 );
-    > {{alias}}( x.length, y.length, x, 1, y, 1, out, 2, 1 )
+    > {{alias}}( x.length, y.length, x, 1, y, 1, out, 2 )
     <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 
     // Using `M`, `N`, and stride parameters:
     > x = new {{alias:@stdlib/array/float64}}( [ 1.0, 0.0, 2.0, 0.0 ] );
     > y = new {{alias:@stdlib/array/float64}}( [ 3.0, 4.0 ] );
     > out = new {{alias:@stdlib/array/float64}}( 8 );
-    > {{alias}}( 2, y.length, x, 2, y, 1, out, 2, 1 )
+    > {{alias}}( 2, y.length, x, 2, y, 1, out, 2 )
     <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 
 
-{{alias}}.ndarray(M,N,x,strideX,offsetX,y,strideY,offsetY,out,sO1,sO2,oO)
+{{alias}}.ndarray(M,N,x,strideX,offsetX,y,strideY,offsetY,out,so1,so2,oo)
     Computes the Cartesian product for two double-precision floating-point
     strided arrays using alternative indexing semantics.
 
@@ -96,13 +93,13 @@
     out: Float64Array
         Output array.
 
-    sO1: integer
-        Stride length between consecutive output pairs.
+    so1: integer
+        Stride length of the first dimension of `out`.
 
-    sO2: integer
-        Stride length between elements of each output pair.
+    so2: integer
+        Stride length of the second dimension of `out`.
 
-    oO: integer
+    oo: integer
         Starting index for `out`.
 
     Returns

lib/node_modules/@stdlib/blas/ext/base/dcartesian-product/docs/types/index.d.ts

@@ -32,8 +32,7 @@ interface Routine {
 	* @param y - second input array
 	* @param strideY - stride length for `y`
 	* @param out - output array
-	* @param strideOut1 - stride length between consecutive output pairs
-	* @param strideOut2 - stride length between elements of each output pair
+	* @param LDO - stride of the leading dimension of `out`
 	* @returns output array
 	*
 	* @example
@@ -43,10 +42,10 @@ interface Routine {
 	* var y = new Float64Array( [ 3.0, 4.0 ] );
 	* var out = new Float64Array( 8 );
 	*
-	* dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2, 1 );
+	* dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2 );
 	* // out => <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 	*/
-	( M: number, N: number, x: Float64Array, strideX: number, y: Float64Array, strideY: number, out: Float64Array, strideOut1: number, strideOut2: number ): Float64Array;
+	( M: number, N: number, x: Float64Array, strideX: number, y: Float64Array, strideY: number, out: Float64Array, LDO: number ): Float64Array;
 
 	/**
 	* Computes the Cartesian product for two double-precision floating-point strided arrays using alternative indexing semantics.
@@ -60,8 +59,8 @@ interface Routine {
 	* @param strideY - stride length for `y`
 	* @param offsetY - starting index for `y`
 	* @param out - output array
-	* @param strideOut1 - stride length between consecutive output pairs
-	* @param strideOut2 - stride length between elements of each output pair
+	* @param strideOut1 - stride length of the first dimension of `out`
+	* @param strideOut2 - stride length of the second dimension of `out`
 	* @param offsetOut - starting index for `out`
 	* @returns output array
 	*
@@ -88,8 +87,7 @@ interface Routine {
 * @param y - second input array
 * @param strideY - stride length for `y`
 * @param out - output array
-* @param strideOut1 - stride length between consecutive output pairs
-* @param strideOut2 - stride length between elements of each output pair
+* @param LDO - stride of the leading dimension of `out`
 * @returns output array
 *
 * @example
@@ -99,7 +97,7 @@ interface Routine {
 * var y = new Float64Array( [ 3.0, 4.0 ] );
 * var out = new Float64Array( 8 );
 *
-* dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2, 1 );
+* dcartesianProduct( x.length, y.length, x, 1, y, 1, out, 2 );
 * // out => <Float64Array>[ 1.0, 3.0, 1.0, 4.0, 2.0, 3.0, 2.0, 4.0 ]
 *
 * @example