Merge branch 'develop' into feat/cpolarf

Author: anandkaranubc

lib/node_modules/@stdlib/math/base/special/coversinf/package.json

@@ -71,5 +71,90 @@
     "trigonometry",
     "radians",
     "angle"
-  ]
+  ],
+  "__stdlib__": {
+    "scaffold": {
+      "$schema": "math/[email protected]",
+      "base_alias": "coversin",
+      "alias": "coversinf",
+      "pkg_desc": "compute the coversed sine of a single-precision floating-point number (in radians)",
+      "desc": "computes the coversed sine of a single-precision floating-point number (in radians)",
+      "short_desc": "coversed sine",
+      "parameters": [
+        {
+          "name": "x",
+          "desc": "input value (in radians)",
+          "type": {
+            "javascript": "number",
+            "jsdoc": "number",
+            "c": "float",
+            "dtype": "float32"
+          },
+          "domain": [
+            {
+              "min": "-infinity",
+              "max": "infinity"
+            }
+          ],
+          "rand": {
+            "prng": "random/base/uniform",
+            "parameters": [
+              -10,
+              10
+            ]
+          },
+          "example_values": [
+            64,
+            27,
+            0,
+            0.1,
+            -9,
+            8,
+            -1,
+            125,
+            -10.2,
+            11.3,
+            -12.4,
+            3.5,
+            -1.6,
+            15.7,
+            -16,
+            17.9,
+            -188,
+            19.11,
+            -200,
+            21.15
+          ]
+        }
+      ],
+      "output_policy": "real_floating_point_and_generic",
+      "returns": {
+        "desc": "coversed sine",
+        "type": {
+          "javascript": "number",
+          "jsdoc": "number",
+          "c": "float",
+          "dtype": "float32"
+        }
+      },
+      "keywords": [
+        "coversin",
+        "coversinf",
+        "coversine",
+        "coversed",
+        "coversinus",
+        "covers",
+        "cosiv",
+        "cvs",
+        "versed",
+        "sine",
+        "sin",
+        "trig",
+        "trigonometry",
+        "radians",
+        "angle"
+      ],
+      "extra_keywords": []
+    }
+  }
 }

lib/node_modules/@stdlib/math/base/special/csc/README.md

@@ -117,7 +117,7 @@ Evaluates the [cosecant][trigonometric-functions] of `x` (in radians).
 double out = stdlib_base_csc( 0.0 );
 // returns Infinity
 
-out = stdlib_base_cos( 3.141592653589793 / 2.0 );
+out = stdlib_base_csc( 3.141592653589793 / 2.0 );
 // returns 1.0
 ```
 

lib/node_modules/@stdlib/math/base/special/csc/src/main.c

@@ -26,7 +26,7 @@
 * @return     cosecant
 *
 * @example
-* double y = stdlib_base_cos( 3.141592653589793 / 2.0 );
+* double y = stdlib_base_csc( 3.141592653589793 / 2.0 );
 * // returns 1.0
 */
 double stdlib_base_csc( const double x ) {

lib/node_modules/@stdlib/math/base/special/csc/test/fixtures/julia/huge_positive.json

@@ -19,7 +19,7 @@
 import JSON
 
 """
-    gen( domain, name )
+	gen( domain, name )
 
 Generate fixture data and write to file.
 
@@ -36,22 +36,23 @@ julia> gen( x, \"data.json\" );
 ```
 """
 function gen( domain, name )
-    x = collect( domain );
-    y = csc.( x );
-
-    # Store data to be written to file as a collection:
-    data = Dict([
-        ("x", x),
-        ("expected", y)
-    ]);
-
-    # Based on the script directory, create an output filepath:
-    filepath = joinpath( dir, name );
-
-    # Write the data to the output filepath as JSON:
-    outfile = open( filepath, "w" );
-    write( outfile, JSON.json(data) );
-    close( outfile );
+	x = collect( domain );
+	y = csc.( x );
+
+	# Store data to be written to file as a collection:
+	data = Dict([
+		("x", x),
+		("expected", y)
+	]);
+
+	# Based on the script directory, create an output filepath:
+	filepath = joinpath( dir, name );
+
+	# Write the data to the output filepath as JSON:
+	outfile = open( filepath, "w" );
+	write( outfile, JSON.json(data) );
+	write( outfile, "\n" );
+	close( outfile );
 end
 
 # Get the filename:
@@ -109,5 +110,5 @@ x = range( -2.0^60*(pi/2.0), stop = -2.0^1000*(pi/2.0), length = 1000 )
 gen( x, "huge_negative.json" );
 
 # Huge positive values:
-x = range( 2.0^20*(pi/2.0), stop = 2.0^60*(pi/2.0), length = 1000 )
+x = range( 2.0^60*(pi/2.0), stop = 2.0^1000*(pi/2.0), length = 1000 )
 gen( x, "huge_positive.json" );

lib/node_modules/@stdlib/math/base/special/csc/test/fixtures/julia/runner.jl

@@ -21,7 +21,6 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var IS_BROWSER = require( '@stdlib/assert/is-browser' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
 var BIAS = require( '@stdlib/constants/float64/exponent-bias' );
@@ -63,8 +62,8 @@ tape( 'the function splits a floating-point number into a normalized fraction an
 	for ( i = 0; i < x.length; i++ ) {
 		out = new Float64Array( 2 );
 		f = frexp( x[i], out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
-		t.deepEqual( f, expected[ i ], 'returns expected results for ' + x[i] );
+		t.strictEqual( f, out, 'returns output array' );
+		t.deepEqual( f, expected[ i ], 'returns expected value' );
 	}
 	t.end();
 });
@@ -81,8 +80,8 @@ tape( 'the function splits a floating-point number into a normalized fraction an
 	for ( i = 0; i < x.length; i++ ) {
 		out = new Float64Array( 2 );
 		f = frexp( x[i], out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
-		t.deepEqual( f, expected[ i ], 'returns expected results for ' + x[i] );
+		t.strictEqual( f, out, 'returns output array' );
+		t.deepEqual( f, expected[ i ], 'returns expected value' );
 	}
 	t.end();
 });
@@ -99,8 +98,8 @@ tape( 'the function splits a floating-point number into a normalized fraction an
 	for ( i = 0; i < x.length; i++ ) {
 		out = new Float64Array( 2 );
 		f = frexp( x[i], out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
-		t.deepEqual( f, expected[ i ], 'returns expected results for ' + x[i] );
+		t.strictEqual( f, out, 'returns output array' );
+		t.deepEqual( f, expected[ i ], 'returns expected value' );
 	}
 	t.end();
 });
@@ -117,14 +116,13 @@ tape( 'the function splits a floating-point number into a normalized fraction an
 	for ( i = 0; i < x.length; i++ ) {
 		out = new Float64Array( 2 );
 		f = frexp( x[i], out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
-		t.deepEqual( f, expected[ i ], 'returns expected results for ' + x[i] );
+		t.strictEqual( f, out, 'returns output array' );
+		t.deepEqual( f, expected[ i ], 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the returned normalized fraction and exponent satisfy the relation `x = frac * 2**exp`', function test( t ) {
-	var total;
 	var sign;
 	var frac;
 	var exp;
@@ -133,12 +131,7 @@ tape( 'the returned normalized fraction and exponent satisfy the relation `x = f
 	var f;
 	var i;
 
-	if ( IS_BROWSER ) {
-		total = 200;
-	} else {
-		total = 1000;
-	}
-	for ( i = 0; i < total; i++ ) {
+	for ( i = 0; i < 1000; i++ ) {
 		if ( randu() < 0.5 ) {
 			sign = -1.0;
 		} else {
@@ -149,20 +142,19 @@ tape( 'the returned normalized fraction and exponent satisfy the relation `x = f
 		x = sign * frac * pow( 10.0, exp );
 		out = new Float64Array( 2 );
 		f = frexp( x, out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
+		t.strictEqual( f, out, 'returns output array' );
 
 		if ( f[ 1 ] > BIAS ) {
 			f = f[ 0 ] * pow( 2.0, BIAS ) * pow( 2.0, f[1]-BIAS );
 		} else {
 			f = f[ 0 ] * pow( 2.0, f[ 1 ] );
 		}
-		t.equal( f, x, 'frac * 2^exp equals ' + x );
+		t.strictEqual( f, x, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the absolute value of the normalized fraction is on the interval `[1/2,1)`', function test( t ) {
-	var total;
 	var sign;
 	var frac;
 	var exp;
@@ -171,12 +163,7 @@ tape( 'the absolute value of the normalized fraction is on the interval `[1/2,1)
 	var f;
 	var i;
 
-	if ( IS_BROWSER ) {
-		total = 200;
-	} else {
-		total = 1000;
-	}
-	for ( i = 0; i < total; i++ ) {
+	for ( i = 0; i < 1000; i++ ) {
 		if ( randu() < 0.5 ) {
 			sign = -1.0;
 		} else {
@@ -187,11 +174,11 @@ tape( 'the absolute value of the normalized fraction is on the interval `[1/2,1)
 		x = sign * frac * pow( 10.0, exp );
 		out = new Float64Array( 2 );
 		f = frexp( x, out, 1, 0 );
-		t.equal( f, out, 'returns output array' );
+		t.strictEqual( f, out, 'returns output array' );
 
 		// Compute the absolute value of the normalized fraction:
 		f = abs( f[ 0 ] );
-		t.ok( f >= 0.5 && f < 1.0, 'absolute value of the normalized fraction is on the interval [1/2,1). x: ' + x + '.' );
+		t.ok( f >= 0.5 && f < 1.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -202,8 +189,8 @@ tape( 'if provided `+0`, the function returns `[0,0]`', function test( t ) {
 
 	out = new Float64Array( 2 );
 	f = frexp( 0.0, out, 1, 0 );
-	t.equal( f, out, 'returns output array' );
-	t.deepEqual( f, [0.0, 0], 'returns [0,0]' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.deepEqual( f, [ 0.0, 0 ], 'returns expected value' );
 	t.end();
 });
 
@@ -213,9 +200,9 @@ tape( 'if provided `-0`, the function returns `[-0,0]`', function test( t ) {
 
 	out = new Float64Array( 2 );
 	f = frexp( -0.0, out, 1, 0 );
-	t.equal( f, out, 'returns output array' );
-	t.equal( isNegativeZero( f[0] ), true, 'first element is -0' );
-	t.deepEqual( f, [-0.0, 0], 'returns [-0,0]' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.strictEqual( isNegativeZero( f[0] ), true, 'returns expected value' );
+	t.deepEqual( f, [ -0.0, 0 ], 'returns expected value' );
 	t.end();
 });
 
@@ -225,8 +212,8 @@ tape( 'if provided `+infinity`, the function returns `[+infinity,0]`', function
 
 	out = new Float64Array( 2 );
 	f = frexp( PINF, out, 1, 0 );
-	t.equal( f, out, 'returns output array' );
-	t.deepEqual( f, [PINF, 0], 'returns [+inf,0]' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.deepEqual( f, [ PINF, 0 ], 'returns expected value' );
 	t.end();
 });
 
@@ -236,8 +223,8 @@ tape( 'if provided `-infinity`, the function returns `[-infinity,0]`', function
 
 	out = new Float64Array( 2 );
 	f = frexp( NINF, out, 1, 0 );
-	t.equal( f, out, 'returns output array' );
-	t.deepEqual( f, [NINF, 0], 'returns [-inf,0]' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.deepEqual( f, [ NINF, 0 ], 'returns expected value' );
 	t.end();
 });
 
@@ -247,9 +234,9 @@ tape( 'if provided `NaN`, the function returns `[NaN,0]`', function test( t ) {
 
 	out = new Float64Array( 2 );
 	f = frexp( NaN, out, 1, 0 );
-	t.equal( f, out, 'returns output array' );
-	t.equal( isnan( f[0] ), true, 'first element is NaN' );
-	t.equal( f[ 1 ], 0, 'second element is 0' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.strictEqual( isnan( f[0] ), true, 'returns expected value' );
+	t.strictEqual( f[ 1 ], 0, 'returns expected value' );
 	t.end();
 });
 
@@ -260,9 +247,9 @@ tape( 'the function supports providing an output array', function test( t ) {
 	out = [ 0.0, 0 ];
 	f = frexp( 4.0, out, 1, 0 );
 
-	t.equal( f, out, 'returns output array' );
-	t.equal( f[ 0 ], 0.5, 'has expected first element' );
-	t.equal( f[ 1 ], 3, 'has expected second element' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.strictEqual( f[ 0 ], 0.5, 'returns expected value' );
+	t.strictEqual( f[ 1 ], 3, 'returns expected value' );
 
 	t.end();
 });
@@ -274,9 +261,9 @@ tape( 'the function supports providing an output typed array', function test( t
 	out = new Float64Array( 2 );
 	f = frexp( 4.0, out, 1, 0 );
 
-	t.equal( f, out, 'returns output array' );
-	t.equal( f[ 0 ], 0.5, 'has expected first element' );
-	t.equal( f[ 1 ], 3, 'has expected second element' );
+	t.strictEqual( f, out, 'returns output array' );
+	t.strictEqual( f[ 0 ], 0.5, 'returns expected value' );
+	t.strictEqual( f[ 1 ], 3, 'returns expected value' );
 
 	t.end();
 });