Refactor to support a negative stride and clean-up

kgryte · kgryte · commit 117438b57adf · 2020-04-24T12:22:41.000-07:00
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/README.md b/lib/node_modules/@stdlib/blas/base/gnrm2/README.md
@@ -93,6 +93,8 @@ var z = gnrm2( N, x1, 2 );
 // returns 5.0
 ```
 
+If either `N` or `stride` is less than or equal to `0`, the function returns `0`.
+
 #### gnrm2.ndarray( N, x, stride, offset )
 
 Computes the [L2-norm][l2-norm] of a vector using alternative indexing semantics.
@@ -128,7 +130,7 @@ var z = gnrm2.ndarray( N, x, 2, 1 );
 
 ## Notes
 
--   If `N <= 0` or `stride <= 0`, both functions return `0.0`.
+-   If `N <= 0`, both functions return `0.0`.
 -   `gnrm2()` corresponds to the [BLAS][blas] level 1 function [`dnrm2`][dnrm2] with the exception that this implementation works with any array type, not just Float64Arrays. Depending on the environment, the typed versions ([`dnrm2`][@stdlib/blas/base/dnrm2], [`snrm2`][@stdlib/blas/base/snrm2], etc.) are likely to be significantly more performant.
 
 </section>
@@ -152,7 +154,7 @@ var i;
 
 x = new Float64Array( 10 );
 for ( i = 0; i < x.length; i++ ) {
-    x[ i ] = round( randu() * 100.0 );
+    x[ i ] = round( randu()*100.0 );
 }
 console.log( x );
 
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/gnrm2/benchmark/benchmark.js
@@ -43,7 +43,7 @@ function createBenchmark( len ) {
 
 	x = [];
 	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*10.0 ) - 20.0 );
+		x.push( ( randu()*20.0 ) - 10.0 );
 	}
 	return benchmark;
 
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/gnrm2/benchmark/benchmark.ndarray.js
@@ -43,7 +43,7 @@ function createBenchmark( len ) {
 
 	x = [];
 	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*10.0 ) - 20.0 );
+		x.push( ( randu()*20.0 ) - 10.0 );
 	}
 	return benchmark;
 
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/examples/index.js b/lib/node_modules/@stdlib/blas/base/gnrm2/examples/index.js
@@ -28,7 +28,7 @@ var i;
 
 x = new Float64Array( 10 );
 for ( i = 0; i < x.length; i++ ) {
-	x[ i ] = round( randu() * 10.0 );
+	x[ i ] = round( randu()*10.0 );
 }
 console.log( x );
 
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/gnrm2/lib/ndarray.js
@@ -32,7 +32,7 @@ var pow = require( '@stdlib/math/base/special/pow' );
 *
 * @param {PositiveInteger} N - number of values over which to compute the L2-norm
 * @param {NumericArray} x - input array
-* @param {PositiveInteger} stride - stride length
+* @param {integer} stride - stride length
 * @param {NonNegativeInteger} offset - starting index
 * @returns {number} L2-norm
 *
@@ -49,27 +49,29 @@ function gnrm2( N, x, stride, offset ) {
 	var scale;
 	var ssq;
 	var ax;
+	var ix;
 	var i;
 
-	if ( N <= 0 || stride <= 0 ) {
+	if ( N <= 0 ) {
 		return 0.0;
 	}
 	if ( N === 1 ) {
 		return abs( x[ offset ] );
 	}
+	ix = offset;
 	scale = 0.0;
 	ssq = 1.0;
-	N *= stride;
-	for ( i = offset; i < N; i += stride ) {
-		if ( x[ i ] !== 0.0 ) {
-			ax = abs( x[ i ] );
+	for ( i = 0; i < N; i++ ) {
+		if ( x[ ix ] !== 0.0 ) {
+			ax = abs( x[ ix ] );
 			if ( scale < ax ) {
 				ssq = 1.0 + ( ssq * pow( scale/ax, 2 ) );
 				scale = ax;
 			} else {
 				ssq += pow( ax/scale, 2 );
 			}
 		}
+		ix += stride;
 	}
 	return scale * sqrt( ssq );
 }
diff --git a/lib/node_modules/@stdlib/blas/base/gnrm2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/gnrm2/test/test.ndarray.js
@@ -94,18 +94,26 @@ tape( 'the function supports a `stride` parameter', function test( t ) {
 	t.end();
 });
 
-tape( 'if provided a `stride` parameter less than or equal to `0`, the function returns `0`', function test( t ) {
+tape( 'the function supports a negative `stride` parameter', function test( t ) {
+	var N;
 	var x;
 	var z;
 
-	x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ];
-
-	z = gnrm2( x.length, x, 0, 0 );
-	t.strictEqual( z, 0.0, 'returns expected value' );
+	x = [
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	];
 
-	z = gnrm2( x.length, x, -1, 0 );
-	t.strictEqual( z, 0.0, 'returns expected value' );
+	N = floor( x.length / 2 );
+	z = gnrm2( N, x, -2, x.length-2 );
 
+	t.strictEqual( z, 5.0, 'returns expected value' );
 	t.end();
 });
 

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ function createBenchmark( len ) {`
`43`	`43`
`44`	`44`	`x = [];`
`45`	`45`	`for ( i = 0; i < len; i++ ) {`
`46`		`- x.push( ( randu()*10.0 ) - 20.0 );`
	`46`	`+ x.push( ( randu()*20.0 ) - 10.0 );`
`47`	`47`	`}`
`48`	`48`	`return benchmark;`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ var i;`
`28`	`28`
`29`	`29`	`x = new Float64Array( 10 );`
`30`	`30`	`for ( i = 0; i < x.length; i++ ) {`
`31`		`- x[ i ] = round( randu() * 10.0 );`
	`31`	`+ x[ i ] = round( randu()*10.0 );`
`32`	`32`	`}`
`33`	`33`	`console.log( x );`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ var pow = require( '@stdlib/math/base/special/pow' );`
`32`	`32`	`*`
`33`	`33`	`* @param {PositiveInteger} N - number of values over which to compute the L2-norm`
`34`	`34`	`* @param {NumericArray} x - input array`
`35`		`-* @param {PositiveInteger} stride - stride length`
	`35`	`+* @param {integer} stride - stride length`
`36`	`36`	`* @param {NonNegativeInteger} offset - starting index`
`37`	`37`	`* @returns {number} L2-norm`
`38`	`38`	`*`
`@@ -49,27 +49,29 @@ function gnrm2( N, x, stride, offset ) {`
`49`	`49`	`var scale;`
`50`	`50`	`var ssq;`
`51`	`51`	`var ax;`
	`52`	`+ var ix;`
`52`	`53`	`var i;`
`53`	`54`
`54`		`- if ( N <= 0 \|\| stride <= 0 ) {`
	`55`	`+ if ( N <= 0 ) {`
`55`	`56`	`return 0.0;`
`56`	`57`	`}`
`57`	`58`	`if ( N === 1 ) {`
`58`	`59`	`return abs( x[ offset ] );`
`59`	`60`	`}`
	`61`	`+ ix = offset;`
`60`	`62`	`scale = 0.0;`
`61`	`63`	`ssq = 1.0;`
`62`		`- N *= stride;`
`63`		`- for ( i = offset; i < N; i += stride ) {`
`64`		`- if ( x[ i ] !== 0.0 ) {`
`65`		`- ax = abs( x[ i ] );`
	`64`	`+ for ( i = 0; i < N; i++ ) {`
	`65`	`+ if ( x[ ix ] !== 0.0 ) {`
	`66`	`+ ax = abs( x[ ix ] );`
`66`	`67`	`if ( scale < ax ) {`
`67`	`68`	`ssq = 1.0 + ( ssq * pow( scale/ax, 2 ) );`
`68`	`69`	`scale = ax;`
`69`	`70`	`} else {`
`70`	`71`	`ssq += pow( ax/scale, 2 );`
`71`	`72`	`}`
`72`	`73`	`}`
	`74`	`+ ix += stride;`
`73`	`75`	`}`
`74`	`76`	`return scale * sqrt( ssq );`
`75`	`77`	`}`