fix: update documentation and benchmarks to use double for order parameter

Author: 0PrashantYadav0

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

@@ -50,7 +50,7 @@ The function has the following parameters:
 -   **x**: input [`Float64Array`][@stdlib/array/float64].
 -   **strideX**: stride length.
 
-The `N` and stride parameters determine which elements in `x` are accessed at runtime. For example, to sort every other element
+The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to sort every other element:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -94,7 +94,7 @@ The function has the following additional parameters:
 
 -   **offsetX**: starting index.
 
-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:
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on starting a index. For example, to access only the last three elements:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -178,7 +178,7 @@ Sorts a double-precision floating-point strided array using heapsort.
 ```c
 double x[] = { 1.0, -2.0, 3.0, -4.0 };
 
-stdlib_strided_dsorthp( 2, -1, x, 1 );
+stdlib_strided_dsorthp( 2, -1.0, x, 1 );
 ```
 
 The function accepts the following arguments:
@@ -189,7 +189,7 @@ The function accepts the following arguments:
 -   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 
 ```c
-stdlib_strided_dsorthp( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX );
+stdlib_strided_dsorthp( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX );
 ```
 
 <!--lint disable maximum-heading-length-->
@@ -203,19 +203,19 @@ Sorts a double-precision floating-point strided array using heapsort and alterna
 ```c
 double x[] = { 1.0, -2.0, 3.0, -4.0 };
 
-stdlib_strided_dsorthp_ndarray( 4, 1, x, 1, 0 );
+stdlib_strided_dsorthp_ndarray( 4, 1.0, x, 1, 0 );
 ```
 
 The function accepts the following arguments:
 
 -   **N**: `[in] CBLAS_INT` number of indexed elements.
--   **order**: `[in] CBLAS_INT` sort order.
+-   **order**: `[in] double` 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.
--   **strideX**: `[in] CBLAS_INT` stride length for `X`.
--   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **strideX**: `[in] CBLAS_INT` stride length.
+-   **offsetX**: `[in] CBLAS_INT` starting index.
 
 ```c
-stdlib_strided_dsorthp_ndarray( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX );
+stdlib_strided_dsorthp_ndarray( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 ```
 
 </section>

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

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

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

@@ -2,8 +2,8 @@
 {{alias}}( N, order, x, strideX )
     Sorts a double-precision floating-point strided array using heapsort.
 
-    The `N` and stride parameters determine which elements in `x` are accessed
-    at runtime.
+    The `N` and stride parameters determine which elements in the strided array
+    are accessed at runtime.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
@@ -73,8 +73,8 @@
     alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
-    buffer, the `offsetX` parameter supports indexing semantics based on a
-    starting index.
+    buffer, the offset parameter supports indexing semantics based on a starting
+    index.
 
     Parameters
     ----------
@@ -92,7 +92,7 @@
         Stride length.
 
     offsetX: integer
-        Starting index of `x`.
+        Starting index.
 
     Returns
     -------

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

@@ -31,12 +31,12 @@ extern "C" {
 /**
 * Sorts a double-precision floating-point strided array using heapsort.
 */
-void API_SUFFIX(stdlib_strided_dsorthp)( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX );
+void API_SUFFIX(stdlib_strided_dsorthp)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX );
 
 /**
 * Sorts a double-precision floating-point strided array using heapsort and alternative indexing semantics.
 */
-void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX );
+void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 
 #ifdef __cplusplus
 }

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

@@ -53,9 +53,7 @@ var ndarray = require( './ndarray.js' );
 * // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
 */
 function dsorthp( N, order, x, strideX ) {
-	var offsetX;
-	offsetX = stride2offset( N, strideX );
-	return ndarray( N, order, x, strideX, offsetX );
+	return ndarray( N, order, x, strideX, stride2offset( N, strideX ) );
 }
 
 

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

@@ -43,7 +43,7 @@ var addon = require( './../src/addon.node' );
 * dsorthp( x.length, 1.0, x, 1, 0 );
 */
 function dsorthp( N, order, x, strideX, offsetX ) {
-	addon.ndarray( N, order, x, strideX, offsetX);
+	addon.ndarray( N, order, x, strideX, offsetX );
 	return x;
 }
 

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

@@ -40,7 +40,7 @@
 * @param X        input array
 * @param strideX  stride length
 */
-void API_SUFFIX(stdlib_strided_dsorthp)( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX) {
+void API_SUFFIX(stdlib_strided_dsorthp)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX) {
 	CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	return API_SUFFIX(stdlib_strided_dsorthp_ndarray)( N, order, X, strideX, ox );
 }
@@ -63,9 +63,11 @@ void API_SUFFIX(stdlib_strided_dsorthp)( const CBLAS_INT N, const double order,
 * @param strideX  stride length
 * @param offsetX  starting index
 */
-void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double order, double *X, CBLAS_INT strideX, CBLAS_INT offsetX ) {
+void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ) {
 	CBLAS_INT parent;
 	CBLAS_INT child;
+	CBLAS_INT ox;
+	CBLAS_INT sx;
 	CBLAS_INT n;
 	CBLAS_INT i;
 	CBLAS_INT j;
@@ -79,8 +81,8 @@ void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double
 	}
 	// For a positive stride, sorting in decreasing order is equivalent to providing a negative stride and sorting in increasing order, and, for a negative stride, sorting in decreasing order is equivalent to providing a positive stride and sorting in increasing order...
 	if ( order < 0.0 ) {
-		strideX *= -1;
-		offsetX -= (N-1) * strideX;
+		sx = -strideX;
+		ox = offsetX - ( (N-1)*sx );
 	}
 	// Set the initial heap size:
 	n = N;
@@ -93,7 +95,7 @@ void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double
 		if ( parent > 0 ) {
 			// We need to build the heap...
 			parent -= 1;
-			t = X[ offsetX+(parent*strideX) ];
+			t = X[ ox+(parent*sx) ];
 		} else {
 			// Reduce the heap size:
 			n -= 1;
@@ -103,11 +105,11 @@ void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double
 				return;
 			}
 			// Store the last heap value in a temporary variable in order to make room for the heap root being placed into its sorted position:
-			i = offsetX + (n*strideX);
+			i = ox + (n*sx);
 			t = X[ i ];
 
 			// Move the heap root to its sorted position:
-			X[ i ] = X[ offsetX ];
+			X[ i ] = X[ ox ];
 		}
 		// We need to "sift down", pushing `t` down the heap to in order to replace the parent and satisfy the heap property...
 
@@ -121,19 +123,19 @@ void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double
 			// Find the largest child...
 			k = child + 1;
 			if ( k < n ) {
-				v1 = X[ offsetX+(k*strideX) ];
-				v2 = X[ offsetX+(child*strideX) ];
+				v1 = X[ ox+(k*sx) ];
+				v2 = X[ ox+(child*sx) ];
 
 				// Check if a "right" child exists and is "bigger"...
 				if ( v1 > v2 || stdlib_base_is_nan( v1 ) || (v1 == v2 && stdlib_base_is_positive_zero( v1 ) ) ) {
 					child += 1;
 				}
 			}
 			// Check if the largest child is bigger than `t`...
-			v1 = X[ offsetX+(child*strideX) ];
+			v1 = X[ ox+(child*sx) ];
 			if ( v1 > t || stdlib_base_is_nan( v1 ) || ( v1 == t && stdlib_base_is_positive_zero( v1 ) ) ) {
 				// Insert the larger child value:
-				X[ offsetX+(j*strideX) ] = v1;
+				X[ ox+(j*sx) ] = v1;
 
 				// Update `j` to point to the child index:
 				j = child;
@@ -146,6 +148,6 @@ void API_SUFFIX(stdlib_strided_dsorthp_ndarray)( const CBLAS_INT N, const double
 			}
 		}
 		// Insert `t` into the heap:
-		X[ offsetX+(j*strideX) ] = t;
+		X[ ox+(j*sx) ] = t;
 	}
 }