refactor: apply suggestions from code review

Signed-off-by: Muhammad Haris <[email protected]>

Author: headlessNode

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

@@ -54,11 +54,11 @@ The function has the following parameters:
 -   **N**: number of indexed elements.
 -   **order**: sort order. If `order < 0.0`, the input strided array `x` is sorted in **decreasing** order. If `order > 0.0`, the input strided array `x` is sorted in **increasing** order. If `order == 0.0`, the input strided arrays are left unchanged.
 -   **x**: first input [`Float64Array`][@stdlib/array/float64].
--   **strideX**: `x` stride length.
+-   **strideX**: stride length for `x`.
 -   **y**: second input [`Float64Array`][@stdlib/array/float64].
--   **strideY**: `y` stride length.
+-   **strideY**: stride length for `y`.
 
-The `N` and stride parameters determine which elements in `x` and `y` are accessed at runtime. For example, to sort every other element:
+The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to sort every other element:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -123,8 +123,8 @@ console.log( y );
 
 The function has the following additional parameters:
 
--   **offsetX**: `x` starting index.
--   **offsetY**: `y` starting index.
+-   **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 parameters support indexing semantics based on starting indices. For example, to access only the last three elements:
 
@@ -224,20 +224,20 @@ Simultaneously sorts two double-precision floating-point strided arrays based on
 double x[] = { 1.0, -2.0, 3.0, -4.0 };
 double y[] = { 0.0, 1.0, 2.0, 3.0 };
 
-stdlib_strided_dsort2hp( 4, 1, x, 1, y, 1 );
+stdlib_strided_dsort2hp( 4, 1.0, x, 1, y, 1 );
 ```
 
 The function accepts the following arguments:
 
 -   **N**: `[in] CBLAS_INT` number of indexed elements.
--   **order**: `[in] CBLAS_INT` sort order. If `order < 0.0`, the input strided array `x` is sorted in **decreasing** order. If `order > 0.0`, the input strided array `x` is sorted in **increasing** order. If `order == 0.0`, the input strided arrays are left unchanged.
+-   **order**: `[in] double` sort order. If `order < 0.0`, the input strided array `x` is sorted in **decreasing** order. If `order > 0.0`, the input strided array `x` is sorted in **increasing** order. If `order == 0.0`, the input strided arrays are left unchanged.
 -   **X**: `[inout] double*` input array.
 -   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **Y**: `[inout] double*` input array.
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 
 ```c
-stdlib_strided_dsort2hp( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, double *Y, CBLAS_INT strideY );
+stdlib_strided_dsort2hp( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX, double *Y, CBLAS_INT strideY );
 ```
 
 <!--lint disable maximum-heading-length-->
@@ -252,22 +252,22 @@ Simultaneously sorts two double-precision floating-point strided arrays based on
 double x[] = { 1.0, -2.0, 3.0, -4.0 };
 double y[] = { 0.0, 1.0, 2.0, 3.0 };
 
-stdlib_strided_dsort2hp_ndarray( 4, 1, x, 1, 0, y, 1, 0 );
+stdlib_strided_dsort2hp_ndarray( 4, 1.0, x, 1, 0, y, 1, 0 );
 ```
 
 The function accepts the following arguments:
 
 -   **N**: `[in] CBLAS_INT` number of indexed elements.
--   **order**: `[in] CBLAS_INT` sort order.
--   **X**: `[inout] double*` input array. If `order < 0.0`, the input strided array `x` is sorted in **decreasing** order. If `order > 0.0`, the input strided array `x` is sorted in **increasing** order. If `order == 0.0`, the input strided arrays are left unchanged.
+-   **order**: `[in] double` sort order.
+-   **X**: `[inout] double*` input array.
 -   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
 -   **Y**: `[inout] double*` input array.
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 -   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
 
 ```c
-stdlib_strided_dsort2hp_ndarray( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX, double *Y, CBLAS_INT strideY, CBLAS_INT offsetY );
+stdlib_strided_dsort2hp_ndarray( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX, double *Y, CBLAS_INT strideY, CBLAS_INT offsetY );
 ```
 
 </section>

lib/node_modules/@stdlib/blas/ext/base/dsort2hp/benchmark/c/benchmark.unsorted_random.length.c

@@ -107,7 +107,7 @@ static double benchmark1( int iterations, int len ) {
 	}
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		stdlib_strided_dsort2hp( len, 1, x, 1, y, 1 );
+		stdlib_strided_dsort2hp( len, 1.0, x, 1, y, 1 );
 		if ( y[ 0 ] != y[ 0 ] ) {
 			printf( "should not return NaN\n" );
 			break;
@@ -140,7 +140,7 @@ static double benchmark2( int iterations, int len ) {
 	}
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		stdlib_strided_dsort2hp_ndarray( len, 1, x, 1, 0, y, 1, 0 );
+		stdlib_strided_dsort2hp_ndarray( len, 1.0, x, 1, 0, y, 1, 0 );
 		if ( y[ 0 ] != y[ 0 ] ) {
 			printf( "should not return NaN\n" );
 			break;

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

@@ -3,7 +3,7 @@
     Simultaneously sorts two double-precision floating-point strided arrays
     based on the sort order of the first array using heapsort.
 
-    The `N` and stride parameters determine which elements in `x` and `y` are
+    The `N` and stride parameters determine which elements in the strided arrays
     accessed at runtime.
 
     Indexing is relative to the first index. To introduce an offset, use typed

lib/node_modules/@stdlib/blas/ext/base/dsort2hp/include/stdlib/blas/ext/base/dsort2hp.h

@@ -31,12 +31,12 @@ extern "C" {
 /**
 * Simultaneously sorts two double-precision floating-point strided arrays based on the sort order of the first array using heapsort.
 */
-void API_SUFFIX(stdlib_strided_dsort2hp)( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, double *Y, CBLAS_INT strideY );
+void API_SUFFIX(stdlib_strided_dsort2hp)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, double *Y, const CBLAS_INT strideY );
 
 /**
 * Simultaneously sorts two double-precision floating-point strided arrays based on the sort order of the first array using heapsort and alternative indexing semantics.
 */
-void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX, double *Y, CBLAS_INT strideY, CBLAS_INT offsetY );
+void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 
 #ifdef __cplusplus
 }

lib/node_modules/@stdlib/blas/ext/base/dsort2hp/lib/dsort2hp.js

@@ -41,9 +41,9 @@ var ndarray = require( './ndarray.js' );
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} order - sort order
 * @param {Float64Array} x - first input array
-* @param {integer} strideX - `x` stride length
+* @param {integer} strideX - stride length for `x`
 * @param {Float64Array} y - second input array
-* @param {integer} strideY - `y` stride length
+* @param {integer} strideY - stride length for `y`
 * @returns {Float64Array} `x`
 *
 * @example
@@ -61,12 +61,8 @@ var ndarray = require( './ndarray.js' );
 * // => <Float64Array>[ 3.0, 1.0, 0.0, 2.0 ]
 */
 function dsort2hp( N, order, x, strideX, y, strideY ) {
-	var offsetX;
-	var offsetY;
 
-	offsetX = stride2offset( N, strideX );
-	offsetY = stride2offset( N, strideY );
-	return ndarray( N, order, x, strideX, offsetX, y, strideY, offsetY );
+	return ndarray( N, order, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) );
 }
 
 

lib/node_modules/@stdlib/blas/ext/base/dsort2hp/lib/dsort2hp.native.js

@@ -31,9 +31,9 @@ var addon = require( './../src/addon.node' );
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} order - sort order
 * @param {Float64Array} x - first input array
-* @param {integer} strideX - `x` stride length
+* @param {integer} strideX - stride length for `x`
 * @param {Float64Array} y - second input array
-* @param {integer} strideY - `y` stride length
+* @param {integer} strideY - stride length for `y`
 * @returns {Float64Array} `x`
 *
 * @example

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

@@ -42,11 +42,11 @@ var floor = require( '@stdlib/math/base/special/floor' );
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} order - sort order
 * @param {Float64Array} x - first input array
-* @param {integer} strideX - `x` stride length
-* @param {NonNegativeInteger} offsetX - `x` starting index
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
 * @param {Float64Array} y - second input array
-* @param {integer} strideY - `y` stride length
-* @param {NonNegativeInteger} offsetY - `y` starting index
+* @param {integer} strideY - stride length for `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
 * @returns {Float64Array} `x`
 *
 * @example

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

@@ -31,11 +31,11 @@ var addon = require( './../src/addon.node' );
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} order - sort order
 * @param {Float64Array} x - first input array
-* @param {integer} strideX - `x` stride length
-* @param {NonNegativeInteger} offsetX - `x` starting index
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
 * @param {Float64Array} y - second input array
-* @param {integer} strideY - `y` stride length
-* @param {NonNegativeInteger} offsetY - `y` starting index
+* @param {integer} strideY - stride length for `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
 * @returns {Float64Array} `x`
 *
 * @example

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

@@ -39,11 +39,11 @@
 * @param N        number of indexed elements
 * @param order    sort order
 * @param X        first input array
-* @param strideX  `X` stride length
+* @param strideX  stride length for `X`
 * @param Y        second input array
-* @param strideY  `Y` stride length
+* @param strideY  stride length for `Y`
 */
-void API_SUFFIX(stdlib_strided_dsort2hp)( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, double *Y, CBLAS_INT strideY ) {
+void API_SUFFIX(stdlib_strided_dsort2hp)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, double *Y, const CBLAS_INT strideY ) {
 	CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
 	API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( N, order, X, strideX, ox, Y, strideY, oy );
@@ -64,13 +64,13 @@ void API_SUFFIX(stdlib_strided_dsort2hp)( const CBLAS_INT N, const CBLAS_INT ord
 * @param N        number of indexed elements
 * @param order    sort order
 * @param X        first input array
-* @param strideX  `X` stride length
-* @param offsetX  `X` starting index
+* @param strideX  stride length for `X`
+* @param offsetX  starting index for `X`
 * @param Y        second input array
-* @param strideY  `Y` stride length
-* @param offsetY  `Y` starting index
+* @param strideY  stride length for `Y`
+* @param offsetY  starting index for `Y`
 */
-void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const CBLAS_INT order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX, double *Y, CBLAS_INT strideY, CBLAS_INT offsetY ) {
+void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
 	CBLAS_INT parent;
 	CBLAS_INT child;
 	CBLAS_INT ix;