feat: update the JS implementation

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: anandkaranubc

lib/node_modules/@stdlib/math/base/special/hyp2f1/lib/hyp2f1ra.js

@@ -20,18 +20,108 @@
 
 // MODULES //
 
-var isNonPositiveInteger = require( '@stdlib/math/base/assert/is-nonpositive-integer' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
+var round = require( '@stdlib/math/base/special/round' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var hyp2f1ra = require( './hyp2f1ra.js' );
+var isNonPositiveInteger = require( './utils.js' ).isNonPositiveInteger;
 
 
 // VARIABLES //
 
+var MACHEP = 1.11022302462515654042E-16;
 var EPS = 1.0e-13;
 var MAX_ITERATIONS = 10000;
 
 
+// FUNCTIONS //
+
+/**
+* Evaluates the Gaussian hypergeometric function by two-term recurrence in `a`.
+*
+* @private
+* @param {number} a - input value
+* @param {number} b - input value
+* @param {number} c - input value
+* @param {number} x - input value
+* @param {number} loss - starting loss of significance
+* @returns {Object} the function value and error
+*/
+function hyp2f1ra( a, b, c, x, loss ) {
+	var f2Val;
+	var f1Val;
+	var f0Val;
+	var err;
+	var da;
+	var f1;
+	var f0;
+	var t;
+	var n;
+
+	loss = 0.0;
+	err = 0.0;
+
+	if ( ( c < 0.0 && a <= c ) || ( c >= 0.0 && a >= c ) ) {
+		da = round( a - c );
+	}
+	else {
+		da = round( a );
+	}
+
+	t = a - da;
+	if ( abs( da ) > MAX_ITERATIONS ) {
+		loss = 1.0;
+		return {
+			'value': NaN,
+			'error': loss
+		};
+	}
+
+	if ( da < 0.0 ) {
+		f2Val = 0.0;
+		f1 = hys2f1( t, b, c, x, err );
+		loss += f1.error;
+		err = f1.error;
+		f0 = hys2f1( t - 1.0, b, c, x, err );
+		loss += f0.error;
+		t -= 1.0;
+		f1Val = f1.value;
+		f0Val = f0.value;
+		for ( n = 1; n < -da; ++n ) {
+			f2Val = f1Val;
+			f1Val = f0Val;
+
+			// eslint-disable-next-line max-len
+			f0Val = -(((((2.0 * t) - c) - (t * x) + (b * x)) * f1Val) + ((t * (x - 1.0)) * f2Val)) / (c - t);
+			t -= 1.0;
+		}
+	}
+	else {
+		f2Val = 0.0;
+		f1 = hys2f1( t, b, c, x, err );
+		loss += f1.error;
+		err = f1.error;
+		f0 = hys2f1( t + 1.0, b, c, x, err ); // CHECK IF err is THE SAME OR NEW ONE
+		loss += f0.error;
+		t += 1.0;
+		f1Val = f1.value;
+		f0Val = f0.value;
+		for ( n = 1; n < da; ++n ) {
+			f2Val = f1Val;
+			f1Val = f0Val;
+
+			// eslint-disable-next-line max-len
+			f0Val = -(((((2.0 * t) - c) - (t * x) + (b * x)) * f1Val) + ((c - t) * f2Val)) / (t * (x - 1.0));
+			t += 1.0;
+		}
+	}
+
+	return {
+		'value': f0Val,
+		'error': loss
+	};
+}
+
+
 // MAIN //
 
 /**
@@ -44,7 +134,6 @@ var MAX_ITERATIONS = 10000;
 * @param {number} x - input value
 * @param {number} loss - starting loss of significance
 * @returns {Object} the function value and error
-*
 */
 function hys2f1( a, b, c, x, loss ) {
 	var intFlag;
@@ -66,19 +155,19 @@ function hys2f1( a, b, c, x, loss ) {
 		a = f;
 	}
 
-	if ( isNonPositiveInteger( b ) && abs( b ) < abs( a ) ) {
+	if ( isNonPositiveInteger( b ) && ( abs( b ) < abs( a ) ) ) {
 		f = b;
 		b = a;
 		a = f;
 		intFlag = 1;
 	}
 
 	// eslint-disable-next-line max-len
-	if ( ( ( abs( a ) > abs( c ) + 1 ) || intFlag ) && ( abs( c - a ) > 2 ) && ( abs( a ) > 2 ) ) {
+	if ( ( ( abs( a ) > abs( c ) + 1.0 ) || intFlag ) && ( abs( c - a ) > 2.0 ) && ( abs( a ) > 2.0 ) ) {
 		return hyp2f1ra( a, b, c, x, loss );
 	}
 
-	i = 0;
+	i = 0.0;
 	umax = 0.0;
 	f = a;
 	g = b;
@@ -90,7 +179,10 @@ function hys2f1( a, b, c, x, loss ) {
 	do {
 		if ( abs( h ) < EPS ) {
 			loss = 1.0;
-			return PINF;
+			return {
+				'value': PINF,
+				'error': loss
+			};
 		}
 		m = k + 1.0;
 		u *= ( ( f + k ) * ( g + k ) * x / ( ( h + k ) * m ) );
@@ -100,14 +192,17 @@ function hys2f1( a, b, c, x, loss ) {
 			umax = k;
 		}
 		k = m;
-		i += 1;
+		i += 1.0;
 		if ( i > MAX_ITERATIONS ) {
 			loss = 1.0;
-			return s;
+			return {
+				'value': s,
+				'error': loss
+			};
 		}
-	} while ( s === 0 || abs( u / s ) > EPS );
+	} while ( s === 0.0 || abs( u / s ) > MACHEP );
 
-	loss = ( ( EPS * umax ) / abs( s ) ) + ( EPS * i );
+	loss = ( ( MACHEP * umax ) / abs( s ) ) + ( MACHEP * i );
 	return {
 		'value': s,
 		'error': loss