refactor: use the single-precision abs function

Signed-off-by: Athan <[email protected]>

Author: kgryte

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

@@ -22,7 +22,7 @@
 
 var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var floor = require( '@stdlib/math/base/special/floor' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var absf = require( '@stdlib/math/base/special/absf' );
 
 
 // VARIABLES //
@@ -78,47 +78,47 @@ function sasumpw( N, x, strideX, offsetX ) {
 	}
 	ix = offsetX;
 	if ( strideX === 0 ) {
-		return float64ToFloat32( N * abs( x[ ix ] ) );
+		return float64ToFloat32( N * absf( x[ ix ] ) );
 	}
 	if ( N < 8 ) {
 		// Use simple summation...
 		s = 0.0;
 		for ( i = 0; i < N; i++ ) {
-			s = float64ToFloat32( s + abs( x[ ix ] ) );
+			s = float64ToFloat32( s + absf( x[ ix ] ) );
 			ix += strideX;
 		}
 		return s;
 	}
 	if ( N <= BLOCKSIZE ) {
 		// Sum a block with 8 accumulators (by loop unrolling, we lower the effective blocksize to 16)...
-		s0 = abs( x[ ix ] );
-		s1 = abs( x[ ix+strideX ] );
-		s2 = abs( x[ ix+(2*strideX) ] );
-		s3 = abs( x[ ix+(3*strideX) ] );
-		s4 = abs( x[ ix+(4*strideX) ] );
-		s5 = abs( x[ ix+(5*strideX) ] );
-		s6 = abs( x[ ix+(6*strideX) ] );
-		s7 = abs( x[ ix+(7*strideX) ] );
+		s0 = absf( x[ ix ] );
+		s1 = absf( x[ ix+strideX ] );
+		s2 = absf( x[ ix+(2*strideX) ] );
+		s3 = absf( x[ ix+(3*strideX) ] );
+		s4 = absf( x[ ix+(4*strideX) ] );
+		s5 = absf( x[ ix+(5*strideX) ] );
+		s6 = absf( x[ ix+(6*strideX) ] );
+		s7 = absf( x[ ix+(7*strideX) ] );
 		ix += 8 * strideX;
 
 		M = N % 8;
 		for ( i = 8; i < N-M; i += 8 ) {
-			s0 = float64ToFloat32( s0 + abs( x[ ix ] ) );
-			s1 = float64ToFloat32( s1 + abs( x[ ix+strideX ] ) );
-			s2 = float64ToFloat32( s2 + abs( x[ ix+(2*strideX) ] ) );
-			s3 = float64ToFloat32( s3 + abs( x[ ix+(3*strideX) ] ) );
-			s4 = float64ToFloat32( s4 + abs( x[ ix+(4*strideX) ] ) );
-			s5 = float64ToFloat32( s5 + abs( x[ ix+(5*strideX) ] ) );
-			s6 = float64ToFloat32( s6 + abs( x[ ix+(6*strideX) ] ) );
-			s7 = float64ToFloat32( s7 + abs( x[ ix+(7*strideX) ] ) );
+			s0 = float64ToFloat32( s0 + absf( x[ ix ] ) );
+			s1 = float64ToFloat32( s1 + absf( x[ ix+strideX ] ) );
+			s2 = float64ToFloat32( s2 + absf( x[ ix+(2*strideX) ] ) );
+			s3 = float64ToFloat32( s3 + absf( x[ ix+(3*strideX) ] ) );
+			s4 = float64ToFloat32( s4 + absf( x[ ix+(4*strideX) ] ) );
+			s5 = float64ToFloat32( s5 + absf( x[ ix+(5*strideX) ] ) );
+			s6 = float64ToFloat32( s6 + absf( x[ ix+(6*strideX) ] ) );
+			s7 = float64ToFloat32( s7 + absf( x[ ix+(7*strideX) ] ) );
 			ix += 8 * strideX;
 		}
 		// Pairwise sum the accumulators:
 		s = float64ToFloat32( float64ToFloat32( float64ToFloat32(s0+s1) + float64ToFloat32(s2+s3) ) + float64ToFloat32( float64ToFloat32(s4+s5) + float64ToFloat32(s6+s7) ) ); // eslint-disable-line max-len
 
 		// Clean-up loop...
 		for ( i; i < N; i++ ) {
-			s = float64ToFloat32( s + abs( x[ ix ] ) );
+			s = float64ToFloat32( s + absf( x[ ix ] ) );
 			ix += strideX;
 		}
 		return s;