fix: update files

Author: ShabiShett07

lib/node_modules/@stdlib/blas/base/srotmg/docs/repl.txt

@@ -23,8 +23,8 @@
 
     Examples
     --------
-    > var out = {{alias}}( 1.0, 1.0, 1.0, 0.0 )
-    <Float32Array>[ -2.0, 0.0, 0.0, 1.0, 0.0 ]
+    > var out = {{alias}}( 3.0, 4.0, 1.5, 2.5 )
+    <Float32Array>[ 1.0, 0.45, 0.0, 0.0, 0.6 ]
 
 
 {{alias}}.assign( d1, d2, x1. y1, out, stride, offset )
@@ -61,8 +61,8 @@
     Examples
     --------
     > var out = new {{alias:@stdlib/array/float32}}( 5 );
-    > var y = {{alias}}.assign( 1.0, 1.0, 1.0, 0.0, out, 1, 0 )
-    <Float32Array>[ -2.0, 0.0, 0.0, 1.0, 0.0 ]
+    > var y = {{alias}}.assign( 3.0, 4.0, 1.5, 2.5, out, 1, 0 )
+    <Float32Array>[ 1.0, 0.45, 0.0, 0.0, 0.6 ]
     > var bool = ( y === out )
     true
 

lib/node_modules/@stdlib/blas/base/srotmg/lib/assign.js

@@ -41,16 +41,16 @@ var RGAM_SQ = 5.9604645e-8;
 * @param {number} d2 - scaling factor for the second vector component
 * @param {number} x1 - first component of the first vector
 * @param {number} y1 - first component of the second vector
-* @param {Float64Array} param - output array
+* @param {Float32Array} param - output array
 * @param {integer} stride - index increment
 * @param {NonNegativeInteger} offset - starting index
-* @returns {Float64Array} - output array
+* @returns {Float32Array} - output array
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 *
-* var out = srotmg( 3.0, 4.0, 1.5, 2.5, new Float64Array( 5 ), 1, 0 );
-* // returns <Float64Array>[ 1.0, 0.45, 0.0, 0.0, 0.6 ]
+* var out = srotmg( 3.0, 4.0, 1.5, 2.5, new Float32Array( 5 ), 1, 0 );
+* // returns <Float32Array>[ 1.0, 0.45, 0.0, 0.0, 0.6 ]
 */
 function srotmg( d1, d2, x1, y1, param, stride, offset ) {
 	var flag;

lib/node_modules/@stdlib/blas/base/srotmg/test/test.assign.js

@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var Float32Array = require( '@stdlib/array/float32' );
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var srotmg = require( './../lib/assign.js' );
 
@@ -42,175 +43,234 @@ tape( 'the function has an arity of 7', function test( t ) {
 tape( 'the function constructs the parameters for a modified Givens plane rotation', function test( t ) {
 	var expected;
 	var values;
+	var delta;
+	var tol;
 	var out;
+	var e;
 	var i;
+	var j;
 
 	expected = [
-	    [ 0.8944271802902222, 0.4472135901451111, 1.0, 1.0, 3.0 ],
-		[ 0.3162277638912201, 0.9486832618713379, 2.0, -4.0, -5.0 ],
-		[ 0.7071067690849304, 0.7071067690849304, 2.0, 2.0, 6.0 ],
-		[ 0.6, 0.8, 2.0, -2.0, -4.0 ],
-		[ 0.6, 0.8, 2.0, 1.5, 2.5 ],
-		[ 0.906183123588562, 0.4228854477405548, 1.0, -1.50, -2.50 ],
-		[ 0.4472135901451111, 0.8944271802902222, 2.0, 3.50, -7.50 ],
-		[ 0.800000011920929, 0.6000000238418579, 1.0, 4.50, -9.50 ]
+		[ 1.0, 0.375, 0.0, 0.0, 0.5 ],
+		[ -1.0, 0.0, 0.0, 0.0, 0.0 ],
+		[ 0.0, 0.0, -0.5, 0.125, 0.0 ],
+		[ 0.0, 0.0, -0.25, 0.1, 0.0 ],
+		[ 1.0, 0.625, 0.0, 0.0, 0.5 ],
+		[ -1.0, 0.0, 0.0, 0.0, 0.0 ],
+		[ 1.0, -0.625, 0.0, 0.0, -0.5 ],
+		[ 1.0, -0.625, 0.0, 0.0, -0.5 ],
+		[ -2.0, 0.0, 0.0, 0.0, 0.0 ],
+		[ 1.0, 0.0, 0.0, 0.0, 0.0 ],
+		[ -2.0, 0.0, 0.0, 0.0, 0.0 ]
 	];
 	values = [
-	  	[ 4.0, 2.0, 1.0, 3.0 ],
-		[ 1.0, 3.0, -4.0, -5.0 ],
-		[ 5.0, 5.0, 2.0, 6.0 ],
-		[ 6.0, 8.0, -2.0, -4.0 ],
-		[ -3.0, -4.0, 1.5, 2.5 ],
-		[ -7.5, -3.5, -1.5, -2.5 ],
-		[ 10.0, 20.0, 3.5, -7.5 ],
-		[ -8.0, -6.0, 4.5, -9.5 ]
+		[ 3.0, 4.0, 1.0, 2.0 ],
+		[ -3.0, 2.0, 2.0, 3.0 ],
+		[ 4.0, 1.0, 2.0, 1.0 ],
+		[ 5.0, 2.0, 4.0, 1.0 ],
+		[ 5.0, 4.0, 1.0, 2.0 ],
+		[ -5.0, 4.0, 1.0, 2.0 ],
+		[ 5.0, 4.0, -1.0, 2.0 ],
+		[ 5.0, 4.0, 1.0, -2.0 ],
+		[ 5.0, 0.0, 1.0, 2.0 ],
+		[ 5.0, 3.0, 0.0, 2.0 ],
+		[ 5.0, 3.0, 1.0, 0.0 ]
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		expected[i] = new Float32Array( expected[i] );
+		e = new Float32Array( expected[i] );
 		out = new Float32Array( 5 );
-		srotmg( values[i][0], values[i][1], values[i][2], values[i][3], out, 1, 0 ); // eslint-disable-line max-len
-		t.deepEqual( out, expected[i], 'returns expected value' );
+		srotmg( float64ToFloat32( values[i][0] ), float64ToFloat32( values[i][1] ), float64ToFloat32( values[i][2] ), float64ToFloat32( values[i][3] ), out, 1, 0 );
+		for ( j = 0; j < out.length; j++ ) {
+			if ( out[j] === e[j] ) {
+				t.strictEqual( out[j], e[j], 'returns expected value' );
+			} else {
+				delta = abs( out[j] - e[j] );
+				tol = 1.5 * EPS * abs( e[j] );
+				t.ok( delta <= tol, 'within tolerance. out: '+out[j]+'. expected: '+e[j]+'. delta: '+delta+'. tol: '+tol+'.' );
+			}
+		}
 	}
-
 	t.end();
 });
 
 tape( 'the function returns an array of NaNs if provided a rotation elimination parameter equal to NaN', function test(t) {
 	var actual;
 	var i;
 
-	actual = srotmg( NaN, 1.0, 2.0, 3.0, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( NaN, 1.0, 2.0, 3.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( 1.0, NaN, 2.0, 3.0, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( 1.0, NaN, 3.0, 4.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( 1.0, 2.0, NaN, 3.0, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( 1.0, 2.0, NaN, 3.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( 1.0, 2.0, 3.0, NaN, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( 1.0, 2.0, 3.0, NaN, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( NaN, NaN, 3.0, 4.0, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( NaN, NaN, 3.0, 4.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( 1.0, NaN, NaN, 3.0, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( 1.0, NaN, NaN, 4.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
 
-	actual = srotmg( 1.0, 2.0, NaN, NaN, new Float32Array( 4 ), 1, 0 );
+	actual = srotmg( 1.0, 2.0, NaN, NaN, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	actual = srotmg( NaN, 2.0, NaN, 3.0, new Float32Array( 4 ), 1, 0 );
+
+	actual = srotmg( NaN, 2.0, NaN, 4.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	actual = srotmg( NaN, 1.0, 2.0, NaN, new Float32Array( 4 ), 1, 0 );
+
+	actual = srotmg( 1.0, NaN, 3.0, NaN, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	actual = srotmg( 1.0, NaN, 3.0, NaN, new Float32Array( 4 ), 1, 0 );
+
+	actual = srotmg( NaN, 2.0, 3.0, NaN, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	t.end();
-});
 
-tape( 'the function returns an array of zeros except s equals to 1 if provided scaling factor for the first vector component equal to 0', function test(t) {
-	var actual;
-	var i;
-	actual = srotmg( 0.0, 1.0, 2.0, 3.0, new Float32Array( 5 ), 1, 0 );
+	actual = srotmg( NaN, NaN, NaN, 4.0, new Float32Array( 5 ), 1, 0 );
 	for ( i = 0; i < actual.length; i++ ) {
-		if ( i === 1 ) {
-			t.strictEqual( actual[ i ], 1.0, 'returns expected value' );
-		} else {
-			t.strictEqual( actual[ i ], 0.0, 'returns expected value' );
-		}
+		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	t.end();
-});
 
-tape( 'the function returns an array with c, s value equal to 0 and param value value equal to 1 if provided scaling factor for the second vector component equal to 0', function test(t) {
-	var actual;
-	var i;
+	actual = srotmg( 1.0, NaN, NaN, NaN, new Float32Array( 5 ), 1, 0 );
+	for ( i = 0; i < actual.length; i++ ) {
+		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
+	}
 
-	actual = srotmg( 1.0, 0.0, 2.0, 3.0, new Float32Array( 5 ), 1, 0 );
-	for ( i = 0; i < ( actual.length - 2 ); i++ ) {
-		if ( i === 1 ) {
-			t.strictEqual( actual[ i ], 0.0, 'returns expected value' );
-		} else {
-			t.strictEqual( actual[ i ], 1.0, 'returns expected value' );
-		}
+	actual = srotmg( NaN, NaN, 3.0, NaN, new Float32Array( 5 ), 1, 0 );
+	for ( i = 0; i < actual.length; i++ ) {
+		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
+	}
+
+	actual = srotmg( NaN, 2.0, NaN, NaN, new Float32Array( 5 ), 1, 0 );
+	for ( i = 0; i < actual.length; i++ ) {
+		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
+	}
+
+	actual = srotmg( NaN, NaN, NaN, NaN, new Float32Array( 5 ), 1, 0 );
+	for ( i = 0; i < actual.length; i++ ) {
+		t.strictEqual( isnanf( actual[i] ), true, 'returns expected value' );
 	}
-	console.log(actual);
 	t.end();
 });
 
 tape( 'the function supports providing a positive stride', function test(t) {
 	var expected;
 	var actual;
+	var delta;
+	var tol;
 	var out;
+	var i;
 
-	expected = new Float32Array( [ 0.857492983341217, 0.0, 0.5144957900047302, 0.0, 1.0, 0.0, 1.0, 0.0, 2.0 ] );
+	expected = new Float32Array( [ 1.0, 0.0, 0.375, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5 ] );
 	out = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	actual = srotmg( 5.0, 3.0, 1.0, 2.0, out, 2, 0 );
+	actual = srotmg( 3.0, 4.0, 1.0, 2.0, out, 2, 0 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value' );
+	for ( i = 0; i < out.length; i++ ) {
+		if ( out[i] === expected[i] ) {
+			t.strictEqual( out[i], expected[i], 'returns expected value' );
+		} else {
+			delta = abs( out[i] - expected[i] );
+			tol = 1.5 * EPS * abs( expected[i] );
+			t.ok( delta <= tol, 'within tolerance. out: '+out[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
 	t.end();
 });
 
 tape( 'the function supports providing a negative stride', function test(t) {
 	var expected;
 	var actual;
+	var delta;
+	var tol;
 	var out;
+	var i;
 
-	expected = new Float32Array( [ 1.0, 0.0, 0.5144957900047302, 0.0, 0.857492983341217, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	out = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	expected = new Float32Array( [ 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.375, 0.0, 1.0 ] );
+	out = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	actual = srotmg( 5.0, 3.0, 1.0, 2.0, out, -2, 4 );
+	actual = srotmg( 3.0, 4.0, 1.0, 2.0, out, -2, 8 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value' );
+	for ( i = 0; i < out.length; i++ ) {
+		if ( out[i] === expected[i] ) {
+			t.strictEqual( out[i], expected[i], 'returns expected value' );
+		} else {
+			delta = abs( out[i] - expected[i] );
+			tol = 1.5 * EPS * abs( expected[i] );
+			t.ok( delta <= tol, 'within tolerance. out: '+out[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
 	t.end();
 });
 
 tape( 'the function supports providing an offset', function test(t) {
 	var expected;
 	var actual;
+	var delta;
+	var tol;
 	var out;
+	var i;
 
-	expected = new Float32Array( [ 0.0, 0.857492983341217, 0.5144957900047302, 1.0, 1.0, 2.0 ] );
+	expected = new Float32Array( [ 0.0, 1.0, 0.375, 0.0, 0.0, 0.5 ] );
 	out = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	actual = srotmg( 5.0, 3.0, 1.0, 2.0, out, 1, 1 );
+	actual = srotmg( 3.0, 4.0, 1.0, 2.0, out, 1, 1 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value' );
+	for ( i = 0; i < out.length; i++ ) {
+		if ( out[i] === expected[i] ) {
+			t.strictEqual( out[i], expected[i], 'returns expected value' );
+		} else {
+			delta = abs( out[i] - expected[i] );
+			tol = 1.5 * EPS * abs( expected[i] );
+			t.ok( delta <= tol, 'within tolerance. out: '+out[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
 	t.end();
 });
 
 tape( 'the function supports providing both a stride and offset', function test(t) {
 	var expected;
 	var actual;
+	var delta;
+	var tol;
 	var out;
+	var i;
 
-	expected = new Float32Array( [ 0.0, 0.0, 0.857492983341217, 0.0, 0.5144957900047302, 0.0, 1.0, 0.0, 1.0, 0.0, 2.0 ] ); // eslint-disable-line max-len
+	expected = new Float32Array( [ 0.0, 0.0, 1.0, 0.0, 0.375, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5 ] ); // eslint-disable-line max-len
 	out = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	actual = srotmg( 5.0, 3.0, 1.0, 2.0, out, 2, 2 );
+	actual = srotmg( 3.0, 4.0, 1.0, 2.0, out, 2, 2 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value' );
+	for ( i = 0; i < out.length; i++ ) {
+		if ( out[i] === expected[i] ) {
+			t.strictEqual( out[i], expected[i], 'returns expected value' );
+		} else {
+			delta = abs( out[i] - expected[i] );
+			tol = 1.5 * EPS * abs( expected[i] );
+			t.ok( delta <= tol, 'within tolerance. out: '+out[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
 	t.end();
 });