fix: lint, benchmarks and test errors

Author: headlessNode

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

@@ -96,11 +96,13 @@ static double rand_double( void ) {
 */
 static double benchmark1( int iterations, int len ) {
 	double elapsed;
-	double x[ len ];
-	double y[ len ];
+	double *x;
+	double *y;
 	double t;
 	int i;
 
+	x = ( double * )malloc( len * sizeof(double) );
+	y = ( double * )malloc( len * sizeof(double) );
 	for ( i = 0; i < len; i++ ) {
 		x[ i ] = ( rand_double()*20.0 ) - 10.0;
 		y[ i ] = ( rand_double()*20.0 ) - 10.0;
@@ -117,6 +119,8 @@ static double benchmark1( int iterations, int len ) {
     if ( y[ 0 ] != y[ 0 ] ) {
         printf( "should not return NaN\n" );
     }
+	free( x );
+	free( y );
 	return elapsed;
 }
 
@@ -129,11 +133,13 @@ static double benchmark1( int iterations, int len ) {
 */
 static double benchmark2( int iterations, int len ) {
 	double elapsed;
-	double x[ len ];
-	double y[ len ];
+	double *x;
+	double *y;
 	double t;
 	int i;
 
+	x = (double *)malloc( len * sizeof(double) );
+	y = (double *)malloc( len * sizeof(double) );
 	for ( i = 0; i < len; i++ ) {
 		x[ i ] = ( rand_double()*20.0 ) - 10.0;
 		y[ i ] = ( rand_double()*20.0 ) - 10.0;
@@ -150,6 +156,8 @@ static double benchmark2( int iterations, int len ) {
     if ( y[ 0 ] != y[ 0 ] ) {
         printf( "should not return NaN\n" );
     }
+	free( x );
+	free( y );
 	return elapsed;
 }
 

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

@@ -4,7 +4,7 @@
     based on the sort order of the first array using heapsort.
 
     The `N` and stride parameters determine which elements in the strided arrays
-    accessed at runtime.
+    are accessed at runtime.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
@@ -91,8 +91,8 @@
     indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
-    buffer, the `offset` parameter supports indexing semantics based on a
-    starting index.
+    buffer, the offset parameters support indexing semantics based on starting
+    indices.
 
     Parameters
     ----------

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

@@ -75,6 +75,10 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 	CBLAS_INT child;
 	CBLAS_INT ix;
 	CBLAS_INT iy;
+	CBLAS_INT sx;
+	CBLAS_INT sy;
+	CBLAS_INT ox;
+	CBLAS_INT oy;
 	CBLAS_INT n;
 	CBLAS_INT j;
 	CBLAS_INT k;
@@ -88,10 +92,15 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 	}
 	// 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;
-		strideY *= -1;
-		offsetX -= (N-1) * strideX;
-		offsetY -= (N-1) * strideY;
+		sx = -strideX;
+		sy = -strideY;
+		ox = offsetX - (N-1) * sx;
+		oy = offsetY - (N-1) * sy;
+	} else {
+		sx = strideX;
+		sy = strideY;
+		ox = offsetX;
+		oy = offsetY;
 	}
 	// Set the initial heap size:
 	n = N;
@@ -104,8 +113,8 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 		if ( parent > 0 ) {
 			// We need to build the heap...
 			parent -= 1;
-			tx = X[ offsetX+(parent*strideX) ];
-			ty = Y[ offsetY+(parent*strideY) ];
+			tx = X[ ox+(parent*sx) ];
+			ty = Y[ oy+(parent*sy) ];
 		} else {
 			// Reduce the heap size:
 			n -= 1;
@@ -115,14 +124,14 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 				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:
-			ix = offsetX + (n*strideX);
+			ix = ox + (n*sx);
 			tx = X[ ix ];
-			iy = offsetY + (n*strideY);
+			iy = oy + (n*sy);
 			ty = Y[ iy ];
 
 			// Move the heap root to its sorted position:
-			X[ ix ] = X[ offsetX ];
-			Y[ iy ] = Y[ offsetY ];
+			X[ ix ] = X[ ox ];
+			Y[ iy ] = Y[ oy ];
 		}
 		// We need to "sift down", pushing `t` down the heap to in order to replace the parent and satisfy the heap property...
 
@@ -136,20 +145,20 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 			// 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 > tx || stdlib_base_is_nan( v1 ) || ( v1 == tx && stdlib_base_is_positive_zero( v1 ) ) ) {
 				// Insert the larger child value:
-				X[ offsetX+(j*strideX) ] = v1;
-				Y[ offsetY+(j*strideY) ] = Y[ offsetY+(child*strideY) ];
+				X[ ox+(j*sx) ] = v1;
+				Y[ oy+(j*sy) ] = Y[ oy+(child*sy) ];
 
 				// Update `j` to point to the child index:
 				j = child;
@@ -162,7 +171,7 @@ void API_SUFFIX(stdlib_strided_dsort2hp_ndarray)( const CBLAS_INT N, const doubl
 			}
 		}
 		// Insert `t` into the heap:
-		X[ offsetX+(j*strideX) ] = tx;
-		Y[ offsetY+(j*strideY) ] = ty;
+		X[ ox+(j*sx) ] = tx;
+		Y[ oy+(j*sy) ] = ty;
 	}
 }