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: 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: 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-power/README.md

@@ -22,12 +22,6 @@ limitations under the License.
 
 > Compute the Cartesian power for a double-precision floating-point strided array.
 
-<section class="intro">
-
-</section>
-
-<!-- /.intro -->
-
 <section class="usage">
 
 ## Usage
@@ -52,13 +46,13 @@ dcartesianPower( 'row-major', x.length, 2, x, 1, out, 2 );
 
 The function has the following parameters:
 
--   **order**: storage layout.
+-   **order**: storage layout. Must be either `'row-major'` or `'column-major'`.
 -   **N**: number of indexed elements.
 -   **k**: power.
 -   **x**: input [`Float64Array`][@stdlib/array/float64].
 -   **strideX**: stride length for `x`.
 -   **out**: output [`Float64Array`][@stdlib/array/float64].
--   **LDO**: stride length for the leading dimension of `out`.
+-   **LDO**: stride length between successive contiguous vectors of the matrix `out` (a.k.a., leading dimension of `out`).
 
 The `N`, `k`, and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the Cartesian power of every other element:
 
@@ -74,27 +68,27 @@ dcartesianPower( 'row-major', 2, 2, x, 2, out, 2 );
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
-<!-- eslint-disable stdlib/capitalized-comments -->
-
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 
-// Initial arrays...
-var x0 = new Float64Array( [ 0.0, 1.0, 2.0 ] );
-var out0 = new Float64Array( 8 );
+// Initial array:
+var x0 = new Float64Array( [ 0.0, 1.0, 2.0, 3.0 ] );
 
-// Create offset views...
+// Create an offset view:
 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-dcartesianPower( 'row-major', 2, 2, x1, 1, out0, 2 );
-// out0 => <Float64Array>[ 1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 2.0, 2.0 ]
+// Output array:
+var out = new Float64Array( 8 );
+
+dcartesianPower( 'row-major', 2, 2, x1, 1, out, 2 );
+// out => <Float64Array>[ 1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 2.0, 2.0 ]
 ```
 
-<!--lint disable maximum-heading-length-->
+<!-- lint disable maximum-heading-length -->
 
 #### dcartesianPower.ndarray( N, k, x, strideX, offsetX, out, strideOut1, strideOut2, offsetOut )
 
-<!--lint enable maximum-heading-length-->
+<!-- lint enable maximum-heading-length -->
 
 Computes the Cartesian power for a double-precision floating-point strided array using alternative indexing semantics.
 
@@ -108,22 +102,27 @@ dcartesianPower.ndarray( x.length, 2, x, 1, 0, out, 2, 1, 0 );
 // out => <Float64Array>[ 1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 2.0, 2.0 ]
 ```
 
-The function has the following additional parameters:
+The function has the following parameters:
 
+-   **N**: number of indexed elements.
+-   **k**: power.
+-   **x**: input [`Float64Array`][@stdlib/array/float64].
+-   **strideX**: stride length for `x`.
 -   **offsetX**: starting index for `x`.
--   **strideOut1**: stride length for the first dimension of `out`.
--   **strideOut2**: stride length for the second dimension of `out`.
+-   **out**: output [`Float64Array`][@stdlib/array/float64].
+-   **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 compute the Cartesian power of every other value in the strided input array starting from the second value:
+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:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 
-var x = new Float64Array( [ 0.0, 1.0, 2.0 ] );
+var x = new Float64Array( [ 0.0, 0.0, 1.0, 2.0 ] );
 var out = new Float64Array( 8 );
 
-dcartesianPower.ndarray( 2, 2, x, 1, 1, out, 2, 1, 0 );
+dcartesianPower.ndarray( 2, 2, x, 1, 2, out, 2, 1, 0 );
 // out => <Float64Array>[ 1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 2.0, 2.0 ]
 ```
 
@@ -135,9 +134,10 @@ dcartesianPower.ndarray( 2, 2, x, 1, 1, out, 2, 1, 0 );
 
 ## Notes
 
+-   `k`-tuples are stored as rows in the output matrix, where the `j`-th column contains the `j`-th element of each tuple.
+-   For an input array of length `N`, the output array must contain at least `N^k * k` indexed elements.
+-   For row-major order, the `LDO` parameter must be greater than or equal to `max(1,k)`. For column-major order, the `LDO` parameter must be greater than or equal to `max(1,N^k)`.
 -   If `N <= 0` or `k <= 0`, both functions return `out` unchanged.
--   The output array must contain at least `N^k * k` elements.
--   The `LDO` parameter must be greater than or equal to `max(1, k)`.
 
 </section>
 
@@ -150,15 +150,20 @@ dcartesianPower.ndarray( 2, 2, x, 1, 1, out, 2, 1, 0 );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var Float64Array = require( '@stdlib/array/float64' );
+var pow = require( '@stdlib/math/base/special/pow' );
 var dcartesianPower = require( '@stdlib/blas/ext/base/dcartesian-power' );
 
-var x = new Float64Array( [ 1.0, 2.0 ] );
+var N = 2;
+var k = 3;
+var x = discreteUniform( N, 1, 10, {
+    'dtype': 'float64'
+});
 console.log( x );
 
-var out = new Float64Array( 24 );
-
-dcartesianPower( 'row-major', x.length, 3, x, 1, out, 3 );
+var out = new Float64Array( pow( N, k ) * k );
+dcartesianPower( 'row-major', N, k, x, 1, out, k );
 console.log( out );
 ```
 
@@ -192,21 +197,17 @@ console.log( out );
 #include "stdlib/blas/ext/base/dcartesianpower.h"
 ```
 
-<!--lint disable maximum-heading-length-->
-
 #### stdlib_strided_dcartesian_power( order, N, k, \*X, strideX, \*Out, LDO )
 
-<!--lint enable maximum-heading-length-->
-
 Computes the Cartesian power for a double-precision floating-point strided array.
 
 ```c
 #include "stdlib/blas/base/shared.h"
 
-const double X[] = { 1.0, 2.0 };
-double Out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+const double x[] = { 1.0, 2.0 };
+double out[ 8 ];
 
-stdlib_strided_dcartesian_power( CblasRowMajor, 2, 2, X, 1, Out, 2 );
+stdlib_strided_dcartesian_power( CblasRowMajor, 2, 2, x, 1, out, 2 );
 ```
 
 The function accepts the following arguments:
@@ -217,25 +218,25 @@ The function accepts the following arguments:
 -   **X**: `[in] double*` input array.
 -   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **Out**: `[out] double*` output array.
--   **LDO**: `[in] CBLAS_INT` stride length for the leading dimension of `Out`.
+-   **LDO**: `[in] CBLAS_INT` stride length between successive contiguous vectors of the matrix `Out` (a.k.a., leading dimension of `Out`). For row-major order, must be greater than or equal to `max(1,k)`. For column-major order, must be greater than or equal to `max(1,N^k)`.
 
 ```c
 void stdlib_strided_dcartesian_power( const CBLAS_LAYOUT order, const CBLAS_INT N, const CBLAS_INT k, const double *X, const CBLAS_INT strideX, double *Out, const CBLAS_INT LDO );
 ```
 
-<!--lint disable maximum-heading-length-->
+<!-- lint disable maximum-heading-length -->
 
 #### stdlib_strided_dcartesian_power_ndarray( N, k, \*X, strideX, offsetX, \*Out, strideOut1, strideOut2, offsetOut )
 
-<!--lint enable maximum-heading-length-->
+<!-- lint enable maximum-heading-length -->
 
 Computes the Cartesian power for a double-precision floating-point strided array using alternative indexing semantics.
 
 ```c
-const double X[] = { 1.0, 2.0 };
-double Out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+const double x[] = { 1.0, 2.0 };
+double out[ 8 ];
 
-stdlib_strided_dcartesian_power_ndarray( 2, 2, X, 1, 0, Out, 2, 1, 0 );
+stdlib_strided_dcartesian_power_ndarray( 2, 2, x, 1, 0, out, 2, 1, 0 );
 ```
 
 The function accepts the following arguments:
@@ -246,8 +247,8 @@ The function accepts the following arguments:
 -   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
 -   **Out**: `[out] double*` output array.
--   **strideOut1**: `[in] CBLAS_INT` stride length for the first dimension of `Out`.
--   **strideOut2**: `[in] CBLAS_INT` stride length for the second dimension of `Out`.
+-   **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
@@ -276,28 +277,30 @@ void stdlib_strided_dcartesian_power_ndarray( const CBLAS_INT N, const CBLAS_INT
 #include "stdlib/blas/ext/base/dcartesianpower.h"
 #include "stdlib/blas/base/shared.h"
 #include <stdio.h>
+#include <math.h>
 
 int main( void ) {
     // Create a strided input array:
-    const double X[] = { 1.0, 2.0 };
+    const double x[] = { 1.0, 2.0 };
 
     // Specify the number of indexed elements and power:
     const int N = 2;
     const int k = 2;
 
-    // Create an output array:
-    double out[ 8 ] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+    // Create an output array (N^k tuples, each tuple has k elements):
+    double out[ 8 ];
 
     // Specify strides:
     const int strideX = 1;
     const int LDO = 2;
 
     // Compute the Cartesian power:
-    stdlib_strided_dcartesian_power( CblasRowMajor, N, k, X, strideX, out, LDO );
+    stdlib_strided_dcartesian_power( CblasRowMajor, N, k, x, strideX, out, LDO );
 
     // Print the result:
-    for ( int i = 0; i < N*N; i++ ) {
-        printf( "out[ %i ] = ( %lf, %lf )\n", i, out[ i*2 ], out[ i*2+1 ] );
+    const int len = (int)pow( N, k );
+    for ( int i = 0; i < len; i++ ) {
+        printf( "out[ %i ] = ( %lf, %lf )\n", i, out[ i*2 ], out[ (i*2)+1 ] );
     }
 }
 ```
@@ -310,12 +313,6 @@ int main( void ) {
 
 <!-- /.c -->
 
-<section class="references">
-
-</section>
-
-<!-- /.references -->
-
 <!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
 
 <section class="related">

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

@@ -32,16 +32,16 @@ var dcartesianPower = require( './../lib/dcartesianpower.js' );
 
 // VARIABLES //
 
-var K = 2;
 var options = {
 	'dtype': 'float64'
 };
+var K = 2;
 
 
 // FUNCTIONS //
 
 /**
-* Creates a benchmark function.
+* Create a benchmark function.
 *
 * @private
 * @param {PositiveInteger} len - array length
@@ -62,18 +62,18 @@ function createBenchmark( len ) {
 	* @param {Benchmark} b - benchmark instance
 	*/
 	function benchmark( b ) {
-		var z;
+		var y;
 		var i;
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dcartesianPower( 'row-major', x.length, K, x, 1, out, K );
-			if ( isnan( z[ 0 ] ) ) {
+			y = dcartesianPower( 'row-major', x.length, K, x, 1, out, K );
+			if ( isnan( y[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( z[ 0 ] ) ) {
+		if ( isnan( y[ 0 ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );
@@ -84,6 +84,11 @@ function createBenchmark( len ) {
 
 // MAIN //
 
+/**
+* Main execution sequence.
+*
+* @private
+*/
 function main() {
 	var len;
 	var min;

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

@@ -37,16 +37,16 @@ var dcartesianPower = tryRequire( resolve( __dirname, './../lib/dcartesianpower.
 var opts = {
 	'skip': ( dcartesianPower instanceof Error )
 };
-var K = 2;
 var options = {
 	'dtype': 'float64'
 };
+var K = 2;
 
 
 // FUNCTIONS //
 
 /**
-* Creates a benchmark function.
+* Create a benchmark function.
 *
 * @private
 * @param {PositiveInteger} len - array length
@@ -67,18 +67,18 @@ function createBenchmark( len ) {
 	* @param {Benchmark} b - benchmark instance
 	*/
 	function benchmark( b ) {
-		var z;
+		var y;
 		var i;
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dcartesianPower( 'row-major', x.length, K, x, 1, out, K );
-			if ( isnan( z[ 0 ] ) ) {
+			y = dcartesianPower( 'row-major', x.length, K, x, 1, out, K );
+			if ( isnan( y[ 0 ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( z[ 0 ] ) ) {
+		if ( isnan( y[ 0 ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );
@@ -89,6 +89,11 @@ function createBenchmark( len ) {
 
 // MAIN //
 
+/**
+* Main execution sequence.
+*
+* @private
+*/
 function main() {
 	var len;
 	var min;