test: added test, test.native, runner

---
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: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - 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: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: nirmaljb

lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/fixtures/cpp/output.json

@@ -334,7 +334,8 @@ void generate( double *x, double *a, double *b, const unsigned int len, const ch
 		lower_unregularized[ i ] = boost::math::beta( arg1, arg2, arg3 );
 		upper_unregularized[ i ] = boost::math::betac( arg1, arg2, arg3 );
 		derivative_regularized[ i ] = boost::math::ibeta_derivative( arg1, arg2, arg3 );
-		derivative_unregularized[i] = derivative_regularized[i] * boost::math::beta(arg1, arg2);
+		// NOTE: `kernel-betainc` currently returns the regularized derivative
+		derivative_unregularized[ i ] = derivative_regularized[ i ];
 	}
 	// Open a new file:
 	f = fopen( name, "w" );

lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/fixtures/cpp/runner.cpp

@@ -23,9 +23,26 @@
 var tape = require( 'tape' );
 var isNaNArray = require( '@stdlib/assert/is-nan-array' );
 var isArray = require( '@stdlib/assert/is-array' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var PI = require( '@stdlib/constants/float64/pi' );
 var kernelBetainc = require( './../lib' );
 
 
+// FIXTURES //
+
+var fixtures = require( './fixtures/cpp/output.json' );
+var lowerRegularized = fixtures.lower_regularized;
+var lowerUnregularized = fixtures.lower_unregularized;
+var upperRegularized = fixtures.upper_regularized;
+var upperUnregularized = fixtures.upper_unregularized;
+var derivativeRegularized = fixtures.derivative_regularized;
+var x = fixtures.x;
+var a = fixtures.a;
+var b = fixtures.b;
+
+
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
@@ -68,7 +85,34 @@ tape( 'the function returns `[ NaN, NaN ]` if `x` is `NaN`', function test( t )
 	t.end();
 });
 
-tape( 'the function returns `[ NaN, NaN ]` if negative `a` or `b`', function test( t ) {
+tape( 'the function returns `[ NaN, NaN ]` if `a` or `b` is `NaN`', function test( t ) {
+	var val = kernelBetainc( 0.5, NaN, 1.0, true, true );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, NaN, 1.0, true, false );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, NaN, 1.0, false, true );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, NaN, 1.0, false, false );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, 1.0, NaN, true, true );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, 1.0, NaN, true, false );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, 1.0, NaN, false, true );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+
+	val = kernelBetainc( 0.5, 1.0, NaN, false, false );
+	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns `[ NaN, NaN ]` if `a` or `b` is negative', function test( t ) {
 	var val = kernelBetainc( 0.5, -1.0, 1.0, true, true );
 	t.strictEqual( isNaNArray( val ), true, 'returns expected value' );
 
@@ -122,4 +166,246 @@ tape( 'attached to the function is a method which supports supplying a destinati
 	t.end();
 });
 
-// TODO: Add fixtures
+tape( 'the function returns expected endpoint values and regularized derivatives when `x` is `0`', function test( t ) {
+	var val;
+
+	val = kernelBetainc( 0.0, 1.0, 2.0, true, false );
+	t.strictEqual( val[ 0 ], 0.0, 'returns expected value for lower regularized endpoint' );
+	t.strictEqual( val[ 1 ], 1.0, 'returns expected regularized derivative for lower regularized endpoint' );
+
+	val = kernelBetainc( 0.0, 1.0, 2.0, true, true );
+	t.strictEqual( val[ 0 ], 1.0, 'returns expected value for upper regularized endpoint' );
+	t.strictEqual( val[ 1 ], 1.0, 'returns expected regularized derivative for upper regularized endpoint' );
+
+	val = kernelBetainc( 0.0, 1.0, 2.0, false, false );
+	t.strictEqual( val[ 0 ], 0.0, 'returns expected value for lower unregularized endpoint' );
+
+	val = kernelBetainc( 0.0, 1.0, 2.0, false, true );
+	t.strictEqual( val[ 0 ], 0.5, 'returns expected value for upper unregularized endpoint' );
+
+	t.end();
+});
+
+tape( 'the function returns expected endpoint values and regularized derivatives when `x` is `1`', function test( t ) {
+	var val;
+
+	val = kernelBetainc( 1.0, 2.0, 1.0, true, false );
+	t.strictEqual( val[ 0 ], 1.0, 'returns expected value for lower regularized endpoint' );
+	t.strictEqual( val[ 1 ], 1.0, 'returns expected regularized derivative for lower regularized endpoint' );
+
+	val = kernelBetainc( 1.0, 2.0, 1.0, true, true );
+	t.strictEqual( val[ 0 ], 0.0, 'returns expected value for upper regularized endpoint' );
+	t.strictEqual( val[ 1 ], 1.0, 'returns expected regularized derivative for upper regularized endpoint' );
+
+	val = kernelBetainc( 1.0, 2.0, 1.0, false, false );
+	t.strictEqual( val[ 0 ], 0.5, 'returns expected value for lower unregularized endpoint' );
+
+	val = kernelBetainc( 1.0, 2.0, 1.0, false, true );
+	t.strictEqual( val[ 0 ], 0.0, 'returns expected value for upper unregularized endpoint' );
+
+	t.end();
+});
+
+tape( 'the function handles the `a=0.5` and `b=0.5` branch', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var val;
+
+	val = kernelBetainc( 0.25, 0.5, 0.5, true, false );
+	expected = 1.0 / 3.0;
+	delta = abs( val[ 0 ] - expected );
+	tol = 50.0 * EPS * abs( expected );
+	t.ok( delta <= tol, 'returns expected lower regularized value. Δ: '+delta+'. tol: '+tol );
+
+	expected = sqrt( 3.0 ) / ( 4.0 * PI );
+	delta = abs( val[ 1 ] - expected );
+	tol = 50.0 * EPS * abs( expected );
+	t.ok( delta <= tol, 'returns expected regularized derivative for lower branch value. Δ: '+delta+'. tol: '+tol );
+
+	val = kernelBetainc( 0.25, 0.5, 0.5, true, true );
+	expected = 2.0 / 3.0;
+	delta = abs( val[ 0 ] - expected );
+	tol = 50.0 * EPS * abs( expected );
+	t.ok( delta <= tol, 'returns expected upper regularized value. Δ: '+delta+'. tol: '+tol );
+
+	expected = PI / 3.0;
+	val = kernelBetainc( 0.25, 0.5, 0.5, false, false );
+	delta = abs( val[ 0 ] - expected );
+	tol = 50.0 * EPS * abs( expected );
+	t.ok( delta <= tol, 'returns expected lower unregularized value. Δ: '+delta+'. tol: '+tol );
+
+	expected = 2.0 * PI / 3.0;
+	val = kernelBetainc( 0.25, 0.5, 0.5, false, true );
+	delta = abs( val[ 0 ] - expected );
+	tol = 50.0 * EPS * abs( expected );
+	t.ok( delta <= tol, 'returns expected upper unregularized value. Δ: '+delta+'. tol: '+tol );
+
+	t.end();
+});
+
+tape( 'the function handles the `b=1` branch', function test( t ) {
+	var val;
+
+	val = kernelBetainc( 0.25, 2.0, 1.0, true, false );
+	t.strictEqual( val[ 0 ], 0.0625, 'returns expected lower regularized value' );
+	t.strictEqual( val[ 1 ], 0.5, 'returns expected regularized derivative for lower regularized value' );
+
+	val = kernelBetainc( 0.25, 2.0, 1.0, true, true );
+	t.strictEqual( val[ 0 ], 0.9375, 'returns expected upper regularized value' );
+	t.strictEqual( val[ 1 ], 0.5, 'returns expected regularized derivative for upper regularized value' );
+
+	val = kernelBetainc( 0.25, 2.0, 1.0, false, false );
+	t.strictEqual( val[ 0 ], 0.03125, 'returns expected lower unregularized value' );
+
+	val = kernelBetainc( 0.25, 2.0, 1.0, false, true );
+	t.strictEqual( val[ 0 ], 0.46875, 'returns expected upper unregularized value' );
+
+	t.end();
+});
+
+tape( 'the function handles the `a=1` branch', function test( t ) {
+	var val;
+
+	val = kernelBetainc( 0.25, 1.0, 2.0, true, false );
+	t.strictEqual( val[ 0 ], 0.4375, 'returns expected lower regularized value' );
+	t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for lower regularized value' );
+
+	val = kernelBetainc( 0.25, 1.0, 2.0, true, true );
+	t.strictEqual( val[ 0 ], 0.5625, 'returns expected upper regularized value' );
+	t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for upper regularized value' );
+
+	val = kernelBetainc( 0.25, 1.0, 2.0, false, false );
+	t.strictEqual( val[ 0 ], 0.21875, 'returns expected lower unregularized value' );
+
+	val = kernelBetainc( 0.25, 1.0, 2.0, false, true );
+	t.strictEqual( val[ 0 ], 0.28125, 'returns expected upper unregularized value' );
+
+	t.end();
+});
+
+tape( 'the function evaluates the lower regularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = lowerRegularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], true, false )[0];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 50.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function evaluates the lower unregularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = lowerUnregularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], false, false )[0];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 90.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function evaluates the upper regularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = upperRegularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], true, true )[0];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 55.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function evaluates the upper unregularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = upperUnregularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], false, true )[0];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 70.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function evaluates the lower derivative regularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = derivativeRegularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], true, false )[1];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 650.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function evaluates the upper derivative regularized incomplete beta function', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var i;
+	var y;
+
+	expected = derivativeRegularized;
+	for ( i = 0; i < x.length; i++ ) {
+		y = kernelBetainc( x[i], a[i], b[i], true, true )[1];
+		if ( y === expected[i] ) {
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', y: '+y+'. a: '+a[i]+'. b: '+b[i]+', expected: '+expected[i] );
+		} else {
+			delta = abs( y - expected[ i ] );
+			tol = 650.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. a: '+a[i]+'. b: '+b[i]+'. y: '+y+'. E: '+expected[i]+'. Δ: '+delta+'. tol: '+tol );
+		}
+	}
+	t.end();
+});