feat: add inline comments

---
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
---

---
type: pre_push_report
description: Results of running various checks prior to pushing changes.
report:
  - task: run_javascript_examples
    status: passed
  - task: run_c_examples
    status: na
  - task: run_cpp_examples
    status: na
  - task: run_javascript_readme_examples
    status: passed
  - task: run_c_benchmarks
    status: na
  - task: run_cpp_benchmarks
    status: na
  - task: run_fortran_benchmarks
    status: na
  - task: run_javascript_benchmarks
    status: passed
  - task: run_julia_benchmarks
    status: na
  - task: run_python_benchmarks
    status: na
  - task: run_r_benchmarks
    status: na
  - task: run_javascript_tests
    status: passed
---

Author: anandkaranubc

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

@@ -52,6 +52,10 @@ var MAX_ITERATIONS = config.MAX_ITERATIONS;
 /**
 * Evaluates the Gaussian hypergeometric function by two-term recurrence in `a`.
 *
+* This helps prevent losing accuracy in the highly alternating hypergeometric series and allows a and b to be reduced to smaller values.
+*
+* AMS55 #15.2.10
+*
 * @private
 * @param {number} a - input value
 * @param {number} b - input value
@@ -82,6 +86,7 @@ function hyp2f1ra( a, b, c, x, loss ) {
 
 	t = a - da;
 	if ( abs( da ) > MAX_ITERATIONS ) {
+		// Too expensive to compute
 		loss = 1.0;
 		return {
 			'value': NaN,
@@ -90,6 +95,7 @@ function hyp2f1ra( a, b, c, x, loss ) {
 	}
 
 	if ( da < 0.0 ) {
+		// Backward recurrence
 		f2Val = 0.0;
 		f1 = hys2f1( t, b, c, x, err );
 		loss += f1.error;
@@ -108,6 +114,7 @@ function hyp2f1ra( a, b, c, x, loss ) {
 			t -= 1.0;
 		}
 	} else {
+		// Forward recurrence
 		f2Val = 0.0;
 		f1 = hys2f1( t, b, c, x, err );
 		loss += f1.error;
@@ -214,6 +221,7 @@ function hys2f1( a, b, c, x, loss ) {
 		}
 	} while ( s === 0.0 || abs( u / s ) > MACHEP );
 
+	// Estimate the relative error due to truncation by the series
 	loss = ( ( MACHEP * umax ) / abs( s ) ) + ( MACHEP * i );
 	return {
 		'value': s,

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

@@ -104,9 +104,11 @@ function hyt2f1( a, b, c, x, loss ) {
 
 	if ( x < -0.5 && !( negIntA || negIntB ) ) {
 		if ( b > a ) {
+			// Transformation based on AMS55 #15.3.4
 			y = hys2f1( a, c - b, c, -x / s, err );
 			val = pow( s, -a ) * y.value;
 		} else {
+			// Transformation based on AMS55 #15.3.5
 			y = hys2f1( c - a, b, c, -x / s, err );
 			val = pow( s, -b ) * y.value;
 		}
@@ -122,10 +124,12 @@ function hyt2f1( a, b, c, x, loss ) {
 
 	if ( x > 0.9 && !negIntA && !negIntB ) {
 		if ( isInteger( d ) === false ) {
+			// Try the power series first:
 			y = hys2f1( a, b, c, x, err );
 			if ( y.error < ETHRESH ) {
 				return y;
 			}
+			// If the power series fails, then apply AMS55 #15.3.6
 			err = y.error;
 			q = hys2f1( a, b, 1.0 - d, s, err );
 			qVal = q.value;
@@ -155,6 +159,7 @@ function hyt2f1( a, b, c, x, loss ) {
 			err += err1 + ( ( MACHEP * max( abs( qVal ), abs( rVal ) ) ) / y );
 			y *= gamma( c );
 		} else {
+			// Psi function expansion, AMS55 #15.3.10, #15.3.11, #15.3.12
 			if ( id >= 0.0 ) {
 				e = d;
 				d1 = d;
@@ -226,6 +231,7 @@ function hyt2f1( a, b, c, x, loss ) {
 			'error': err
 		};
 	}
+	// Use defining power series if no special cases
 	y = hys2f1( a, b, c, x, err );
 	return y;
 }

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

@@ -14,6 +14,19 @@
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
+*
+*
+* ## Notice
+*
+* The original C code and copyright notice are from the [Cephes Mathematical Library]{@link https://www.netlib.org/cephes/}. The implementation has been modified for JavaScript.
+*
+* ```text
+* (C) Copyright Stephen L. Moshier 1984, 1987, 1992, 2000.
+*
+* Use, modification and distribution are subject to the
+* Cephes Mathematical Library License. (See accompanying file
+* LICENSE or copy at https://smath.com/en-US/view/CephesMathLibrary/license)
+* ```
 */
 
 'use strict';

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

@@ -14,6 +14,19 @@
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
+*
+*
+* ## Notice
+*
+* The original C code and copyright notice are from the [Cephes Mathematical Library]{@link https://www.netlib.org/cephes/}. The implementation has been modified for JavaScript.
+*
+* ```text
+* (C) Copyright Stephen L. Moshier 1984, 1987, 1992, 2000.
+*
+* Use, modification and distribution are subject to the
+* Cephes Mathematical Library License. (See accompanying file
+* LICENSE or copy at https://smath.com/en-US/view/CephesMathLibrary/license)
+* ```
 */
 
 'use strict';

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

@@ -141,24 +141,31 @@ function hyp2f1( a, b, c, x ) {
 		return 1.0;
 	}
 
+	/* The transformation for c - a or c - b negative integer
+	* AMS55 #15.3.3
+	*/
 	if ( d <= -1.0 && !( !isIntD && s < 0.0 ) && !( negIntA || negIntB ) ) {
 		return pow( s, d ) * hyp2f1( c - a, c - b, c, x );
 	}
 
+	// The series diverges
 	if ( d <= 0.0 && x === 1.0 && !( negIntA || negIntB ) ) {
 		return PINF;
 	}
 
 	if ( ax < 1.0 || x === -1.0 ) {
 		if ( b === c ) {
+			// 2F1(a,b;b;x) = (1-x)**(-a)
 			return pow( s, -a );
 		}
 		if ( a === c ) {
+			// 2F1(a,b;a;x) = (1-x)**(-b)
 			return pow( s, -b );
 		}
 	}
 
 	if ( negIntC ) {
+		// Check if termination before explosion
 		if ( negIntA && ( ia > ic ) ) {
 			y = hyt2f1( a, b, c, x, err );
 			return y.value;
@@ -170,11 +177,16 @@ function hyp2f1( a, b, c, x ) {
 		return PINF;
 	}
 
+	// Function is a polynomial, so try the power series expansion
 	if ( negIntA || negIntB )	{
 		y = hyt2f1( a, b, c, x, err );
 		return y.value;
 	}
 
+	/**
+	* This transform has a pole for integer b - a and may cause large cancellation errors near |1/x| = 1.
+	* AMS55 #15.3.7
+	*/
 	if ( x < -2.0 && !isInteger( t1 ) ) {
 		p = hyp2f1( a, 1.0 - c + a, 1.0 - b + a, 1.0 / x );
 		q = hyp2f1( b, 1.0 - c + b, 1.0 - a + b, 1.0 / x );
@@ -186,19 +198,24 @@ function hyp2f1( a, b, c, x ) {
 		return ( s * p ) + ( y * q );
 	}
 	if ( x < -1.0 ) {
+		// Transformation based on AMS55 #15.3.4
 		if ( abs( a ) < abs( b ) ) {
 			return pow( s, -a ) * hyp2f1( a, c - b, c, x / ( x - 1.0 ) );
 		}
+		// Transformation based on AMS55 #15.3.5
 		return pow( s, -b ) * hyp2f1( b, c - a, c, x / ( x - 1.0 ) );
 	}
 
+	// The series diverges for |x| > 1 if above checks fail
 	if ( ax > 1.0 ) {
 		return PINF;
 	}
 
 	p = c - a;
 	r = c - b;
 	negIntCaOrCb = isNonPositiveInteger( p ) || isNonPositiveInteger( r );
+
+	// If |x| == 1.0
 	if ( ax === 1.0 ) {
 		if ( x > 0.0 ) {
 			if ( negIntCaOrCb ) {
@@ -218,11 +235,16 @@ function hyp2f1( a, b, c, x ) {
 		}
 	}
 
+	/* Conditionally make d > 0 by recurrence on c
+	* AMS55 #15.2.27
+	*/
 	if ( d < 0.0 ) {
+		// Try the power series first:
 		y = hyt2f1( a, b, c, x, err );
 		if ( y.error < ETHRESH ) {
 			return y.value;
 		}
+		// If the power series fails, then apply the recurrence
 		y = y.value;
 		err = 0.0;
 		aid = 2.0 - id;
@@ -242,11 +264,15 @@ function hyp2f1( a, b, c, x ) {
 		return y;
 	}
 
+	/* The transformation for c - a or c - b negative integer
+	* AMS55 #15.3.3
+	*/
 	if ( negIntCaOrCb ) {
 		y = hys2f1( c - a, c - b, c, x, err );
 		return pow( s, d ) * y.value;
 	}
 
+	// Try the power series
 	y = hyt2f1( a, b, c, x, err );
 	return y.value;
 }