test: added test for ibeta

1. Complete reference taken from boost test_ibeta
2. only a naive test of ibeta_derivate is present, complete test is still left

---
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/int_ab.json

@@ -22,10 +22,24 @@
 * ## Notes
 *
 * -   Run this script from the directory in which fixtures should be written.
+* -   Follows the test data generation patterns from Boost's ibeta_data.cpp
+*     (see https://github.com/boostorg/math/blob/develop/tools/ibeta_data.cpp).
+*     Reference values are computed via Boost library functions, which
+*     internally promote double to long double (80-bit extended on x86),
+*     providing slightly higher precision than double for reference data.
+*
+* ## Fixture Categories (matching Boost's test_ibeta.hpp)
+*
+* 1. output.json          - Medium a,b in [1,40] (original fixture)
+* 2. small_ab.json        - Small a,b in [0,10] (ibeta_small_data style)
+* 3. medium_ab.json       - Medium a,b in [0,100] (ibeta_data style)
+* 4. large_range_ab.json  - Large range a,b ~ 10^-5 to 10^6 (ibeta_large_data style)
+* 5. int_ab.json          - Integer a,b in {1,5,9,...,37} (ibeta_int_data style)
 *
 */
 #include <stdlib.h>
 #include <stdio.h>
+#include <cmath>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include <boost/random/uniform_real_distribution.hpp>
@@ -359,44 +373,330 @@ void generate( double *x, double *a, double *b, const unsigned int len, const ch
 }
 
 /**
-* Main execution sequence.
+* Generates "small a,b" fixture (ibeta_small_data style).
+*
+* Following Boost's beta_data_generator_small: a,b = U[0,100]/10 giving
+* a,b in [0, 10], with random x in (0.0001, 1).
+*
+* @param name  output filename
 */
-int main( void ) {
-	unsigned int len;
+void generate_small_ab( const char *name ) {
+	unsigned int len = 500;
 	double *x;
 	double *a;
 	double *b;
+	unsigned int i;
 
-	// Define the array length:
-	len = 1000;
+	uniform_real_distribution<> rand_x( 0.0001, 1.0 );
+	uniform_real_distribution<> rand_ab( 0.0, 100.0 );
 
-	// Allocate arrays:
 	x = (double*) malloc( len * sizeof(double) );
-	if ( x == NULL ) {
+	a = (double*) malloc( len * sizeof(double) );
+	b = (double*) malloc( len * sizeof(double) );
+	if ( x == NULL || a == NULL || b == NULL ) {
 		printf( "Error allocating memory.\n" );
 		exit( 1 );
 	}
+
+	for ( i = 0; i < len; i++ ) {
+		a[ i ] = rand_ab( rng ) / 10.0;
+		b[ i ] = rand_ab( rng ) / 10.0;
+		x[ i ] = rand_x( rng );
+
+		// Ensure a,b > 0:
+		if ( a[ i ] <= 0.0 ) {
+			a[ i ] = 0.001;
+		}
+		if ( b[ i ] <= 0.0 ) {
+			b[ i ] = 0.001;
+		}
+	}
+
+	generate( x, a, b, len, name );
+	free( x );
+	free( a );
+	free( b );
+}
+
+/**
+* Generates "medium a,b" fixture (ibeta_data style).
+*
+* Following Boost's beta_data_generator_medium: a,b = U[0,100], with
+* random x in (0.0001, 1).
+*
+* @param name  output filename
+*/
+void generate_medium_ab( const char *name ) {
+	unsigned int len = 500;
+	double *x;
+	double *a;
+	double *b;
+	unsigned int i;
+
+	uniform_real_distribution<> rand_x( 0.0001, 1.0 );
+	uniform_real_distribution<> rand_ab( 0.0, 100.0 );
+
+	x = (double*) malloc( len * sizeof(double) );
 	a = (double*) malloc( len * sizeof(double) );
-	if ( a == NULL ) {
+	b = (double*) malloc( len * sizeof(double) );
+	if ( x == NULL || a == NULL || b == NULL ) {
 		printf( "Error allocating memory.\n" );
 		exit( 1 );
 	}
+
+	for ( i = 0; i < len; i++ ) {
+		a[ i ] = rand_ab( rng );
+		b[ i ] = rand_ab( rng );
+		x[ i ] = rand_x( rng );
+
+		// Ensure a,b > 0:
+		if ( a[ i ] <= 0.0 ) {
+			a[ i ] = 0.001;
+		}
+		if ( b[ i ] <= 0.0 ) {
+			b[ i ] = 0.001;
+		}
+	}
+
+	generate( x, a, b, len, name );
+	free( x );
+	free( a );
+	free( b );
+}
+
+/**
+* Generates "large range a,b" fixture (ibeta_large_data style).
+*
+* Following Boost's beta_data_generator: a = U[1,5]*10^k1,
+* b = U[1,5]*10^k2, where k1,k2 are linearly spaced from -5 to 6 (11
+* values each). For each (k1, k2) pair, 10 random x values in (0.0001, 1)
+* are generated.
+*
+* Total: 11 * 11 * 10 = 1210 points.
+*
+* @param name  output filename
+*/
+void generate_large_range_ab( const char *name ) {
+	unsigned int nk = 11;
+	unsigned int nx = 10;
+	unsigned int len = nk * nk * nx;
+	double *x;
+	double *a;
+	double *b;
+	unsigned int idx;
+	unsigned int ik1;
+	unsigned int ik2;
+	unsigned int ix;
+	double k1;
+	double k2;
+
+	uniform_real_distribution<> rand_x( 0.0001, 1.0 );
+	uniform_real_distribution<> rand_scale( 1.0, 5.0 );
+
+	// Linearly spaced exponents from -5 to 6 (11 values):
+	double exponents[ 11 ];
+	linspace_f64( exponents, nk, -5.0, 6.0 );
+
+	x = (double*) malloc( len * sizeof(double) );
+	a = (double*) malloc( len * sizeof(double) );
 	b = (double*) malloc( len * sizeof(double) );
-	if ( b == NULL ) {
+	if ( x == NULL || a == NULL || b == NULL ) {
 		printf( "Error allocating memory.\n" );
 		exit( 1 );
 	}
 
-	// Generate fixture data:
+	idx = 0;
+	for ( ik1 = 0; ik1 < nk; ik1++ ) {
+		k1 = exponents[ ik1 ];
+		for ( ik2 = 0; ik2 < nk; ik2++ ) {
+			k2 = exponents[ ik2 ];
+			for ( ix = 0; ix < nx; ix++ ) {
+				a[ idx ] = rand_scale( rng ) * pow( 10.0, k1 );
+				b[ idx ] = rand_scale( rng ) * pow( 10.0, k2 );
+				x[ idx ] = rand_x( rng );
+				idx++;
+			}
+		}
+	}
+
+	generate( x, a, b, len, name );
+	free( x );
+	free( a );
+	free( b );
+}
+
+/**
+* Generates "integer a,b" fixture (ibeta_int_data style).
+*
+* Following Boost's beta_data_generator_int: a,b from {1,5,9,...,37}
+* (10 integer values, step 4), with 10 random x values in (0.0001, 1) for
+* each (a, b) pair.
+*
+* Total: 10 * 10 * 10 = 1000 points.
+*
+* @param name  output filename
+*/
+void generate_int_ab( const char *name ) {
+	unsigned int na = 10;
+	unsigned int nx = 10;
+	unsigned int len = na * na * nx;
+	double *x;
+	double *a;
+	double *b;
+	unsigned int idx;
+	unsigned int ia;
+	unsigned int ib;
+	unsigned int ix;
+
+	int ab_vals[ 10 ] = { 1, 5, 9, 13, 17, 21, 25, 29, 33, 37 };
+
+	uniform_real_distribution<> rand_x( 0.0001, 1.0 );
+
+	x = (double*) malloc( len * sizeof(double) );
+	a = (double*) malloc( len * sizeof(double) );
+	b = (double*) malloc( len * sizeof(double) );
+	if ( x == NULL || a == NULL || b == NULL ) {
+		printf( "Error allocating memory.\n" );
+		exit( 1 );
+	}
+
+	idx = 0;
+	for ( ia = 0; ia < na; ia++ ) {
+		for ( ib = 0; ib < na; ib++ ) {
+			for ( ix = 0; ix < nx; ix++ ) {
+				a[ idx ] = (double) ab_vals[ ia ];
+				b[ idx ] = (double) ab_vals[ ib ];
+				x[ idx ] = rand_x( rng );
+				idx++;
+			}
+		}
+	}
+
+	generate( x, a, b, len, name );
+	free( x );
+	free( a );
+	free( b );
+}
+
+/**
+* Generates "large asymmetric" fixture (ibeta_large_asym_data style).
+*
+* Following Boost's beta_data_generator_asym: a,b are geometrically
+* spaced from 0.1 to 50. For each (a,b) pair, x is placed near the
+* distribution mean a/(a+b) by multiplying with factors that approach
+* 1 from below and above. This stress-tests the crossover decision
+* boundary where the code chooses between the direct and reflected
+* incomplete beta formulas.
+*
+* Multipliers from Boost: {0.9, 0.99, 0.9999, 0.99999, 0.999999,
+*   0.99999999, 1.001, 1.1, 1.00001, 1.0000001, 1.000000001}
+*
+* Total: 10 * 10 * 11 = 1100 points (minus invalid x >= 1).
+*
+* @param name  output filename
+*/
+void generate_large_asym( const char *name ) {
+	unsigned int na = 10;
+	unsigned int nmul = 11;
+	unsigned int max_len;
+	unsigned int idx;
+	unsigned int i;
+	unsigned int j;
+	unsigned int k;
+	double *x;
+	double *a;
+	double *b;
+	double a_val;
+	double b_val;
+	double x0;
+	double xv;
+
+	// Geometrically spaced a,b from 0.1 to 50 (10 values):
+	double ab_vals[ 10 ];
+	for ( i = 0; i < na; i++ ) {
+		ab_vals[ i ] = 0.1 * pow( 500.0, (double)i / (double)(na - 1) );
+	}
+
+	// Multipliers from Boost's beta_data_generator_asym:
+	double muls[ 11 ] = {
+		0.9, 0.99, 0.9999, 0.99999, 0.999999,
+		0.99999999, 1.001, 1.1, 1.00001, 1.0000001,
+		1.000000001
+	};
+
+	max_len = na * na * nmul;
+	x = (double*) malloc( max_len * sizeof(double) );
+	a = (double*) malloc( max_len * sizeof(double) );
+	b = (double*) malloc( max_len * sizeof(double) );
+	if ( x == NULL || a == NULL || b == NULL ) {
+		printf( "Error allocating memory.\n" );
+		exit( 1 );
+	}
+
+	idx = 0;
+	for ( i = 0; i < na; i++ ) {
+		for ( j = 0; j < na; j++ ) {
+			a_val = ab_vals[ i ];
+			b_val = ab_vals[ j ];
+			x0 = a_val / ( a_val + b_val );
+			for ( k = 0; k < nmul; k++ ) {
+				xv = x0 * muls[ k ];
+				if ( xv >= 1.0 || xv <= 0.0 ) {
+					continue;
+				}
+				a[ idx ] = a_val;
+				b[ idx ] = b_val;
+				x[ idx ] = xv;
+				idx++;
+			}
+		}
+	}
+
+	generate( x, a, b, idx, name );
+	free( x );
+	free( a );
+	free( b );
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	unsigned int len;
+	double *x;
+	double *a;
+	double *b;
+
+	len = 1000;
+	x = (double*) malloc( len * sizeof(double) );
+	a = (double*) malloc( len * sizeof(double) );
+	b = (double*) malloc( len * sizeof(double) );
+	if ( x == NULL || a == NULL || b == NULL ) {
+		printf( "Error allocating memory.\n" );
+		exit( 1 );
+	}
 	rand_array_f64( x, len, 0.001, 0.999 );
 	rand_array_f64( a, len, 1.0, 40.0 );
 	rand_array_f64( b, len, 1.0, 40.0 );
 	generate( x, a, b, len, "output.json" );
 
-	// Free allocated memory:
 	free( x );
 	free( a );
 	free( b );
 
+	generate_small_ab( "small_ab.json" );
+
+	generate_medium_ab( "medium_ab.json" );
+
+	generate_large_range_ab( "large_range_ab.json" );
+
+	generate_int_ab( "int_ab.json" );
+
+	// ---------------------------------------------------------------
+	// 6. Large asymmetric (ibeta_large_asym_data style): x near mean
+	//    10 * 10 * 11 ~ 1100 points (minus invalid)
+	// ---------------------------------------------------------------
+	generate_large_asym( "large_asym.json" );
+
 	return 0;
 }