int
gsl_sf_hyperg_2F1_conj_renorm_e(const double aR, const double aI, const double c,
const double x,
gsl_sf_result * result
)
{
const double rintc = floor(c + 0.5);
const double rinta = floor(aR + 0.5);
const int a_neg_integer = ( aR < 0.0 && fabs(aR-rinta) < locEPS && aI == 0.0);
const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );
if(c_neg_integer) {
if(a_neg_integer && aR > c+0.1) {
/* 2F1 terminates early */
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else {
/* 2F1 does not terminate early enough, so something survives */
/* [Abramowitz+Stegun, 15.1.2] */
gsl_sf_result g1, g2;
gsl_sf_result g3;
gsl_sf_result a1, a2;
int stat = 0;
stat += gsl_sf_lngamma_complex_e(aR-c+1, aI, &g1, &a1);
stat += gsl_sf_lngamma_complex_e(aR, aI, &g2, &a2);
stat += gsl_sf_lngamma_e(-c+2.0, &g3);
if(stat != 0) {
DOMAIN_ERROR(result);
}
else {
gsl_sf_result F;
int stat_F = gsl_sf_hyperg_2F1_conj_e(aR-c+1, aI, -c+2, x, &F);
double ln_pre_val = 2.0*(g1.val - g2.val) - g3.val;
double ln_pre_err = 2.0 * (g1.err + g2.err) + g3.err;
int stat_e = gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,
F.val, F.err,
result);
return GSL_ERROR_SELECT_2(stat_e, stat_F);
}
}
}
else {
/* generic c */
gsl_sf_result F;
gsl_sf_result lng;
double sgn;
int stat_g = gsl_sf_lngamma_sgn_e(c, &lng, &sgn);
int stat_F = gsl_sf_hyperg_2F1_conj_e(aR, aI, c, x, &F);
int stat_e = gsl_sf_exp_mult_err_e(-lng.val, lng.err,
sgn*F.val, F.err,
result);
return GSL_ERROR_SELECT_3(stat_e, stat_F, stat_g);
}
}
static VALUE rb_gsl_sf_lngamma_sgn_e(VALUE obj, VALUE x)
{
gsl_sf_result *rslt = NULL;
VALUE v;
int status;
double sgn;
Need_Float(x);
v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
status = gsl_sf_lngamma_sgn_e(NUM2DBL(x), rslt, &sgn);
return rb_ary_new3(2, v, rb_float_new(sgn));
}
static VALUE rb_gsl_sf_lngamma_sgn_e(VALUE obj, VALUE x)
{
gsl_sf_result *rslt = NULL;
VALUE v;
// local variable "status" declared and set, but never used
//int status;
double sgn;
Need_Float(x);
v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
/*status =*/ gsl_sf_lngamma_sgn_e(NUM2DBL(x), rslt, &sgn);
return rb_ary_new3(2, v, rb_float_new(sgn));
}
int
gsl_sf_hyperg_2F1_renorm_e(const double a, const double b, const double c,
const double x,
gsl_sf_result * result
)
{
const double rinta = floor(a + 0.5);
const double rintb = floor(b + 0.5);
const double rintc = floor(c + 0.5);
const int a_neg_integer = ( a < 0.0 && fabs(a - rinta) < locEPS );
const int b_neg_integer = ( b < 0.0 && fabs(b - rintb) < locEPS );
const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );
if(c_neg_integer) {
if((a_neg_integer && a > c+0.1) || (b_neg_integer && b > c+0.1)) {
/* 2F1 terminates early */
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else {
/* 2F1 does not terminate early enough, so something survives */
/* [Abramowitz+Stegun, 15.1.2] */
gsl_sf_result g1, g2, g3, g4, g5;
double s1, s2, s3, s4, s5;
int stat = 0;
stat += gsl_sf_lngamma_sgn_e(a-c+1, &g1, &s1);
stat += gsl_sf_lngamma_sgn_e(b-c+1, &g2, &s2);
stat += gsl_sf_lngamma_sgn_e(a, &g3, &s3);
stat += gsl_sf_lngamma_sgn_e(b, &g4, &s4);
stat += gsl_sf_lngamma_sgn_e(-c+2, &g5, &s5);
if(stat != 0) {
DOMAIN_ERROR(result);
}
else {
gsl_sf_result F;
int stat_F = gsl_sf_hyperg_2F1_e(a-c+1, b-c+1, -c+2, x, &F);
double ln_pre_val = g1.val + g2.val - g3.val - g4.val - g5.val;
double ln_pre_err = g1.err + g2.err + g3.err + g4.err + g5.err;
double sg = s1 * s2 * s3 * s4 * s5;
int stat_e = gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,
sg * F.val, F.err,
result);
return GSL_ERROR_SELECT_2(stat_e, stat_F);
}
}
}
else {
/* generic c */
gsl_sf_result F;
gsl_sf_result lng;
double sgn;
int stat_g = gsl_sf_lngamma_sgn_e(c, &lng, &sgn);
int stat_F = gsl_sf_hyperg_2F1_e(a, b, c, x, &F);
int stat_e = gsl_sf_exp_mult_err_e(-lng.val, lng.err,
sgn*F.val, F.err,
result);
return GSL_ERROR_SELECT_3(stat_e, stat_F, stat_g);
}
}
CAMLprim value ml_gsl_sf_lngamma_sgn_e(value x)
{
gsl_sf_result res;
double sgn;
gsl_sf_lngamma_sgn_e(Double_val(x), &res, &sgn);
{
CAMLparam0();
CAMLlocal3(v,r,s);
r=val_of_result(&res);
s=copy_double(sgn);
v=alloc_small(2, 0);
Field(v, 0)=r;
Field(v, 1)=s;
CAMLreturn(v);
}
}
int
gsl_sf_hyperg_0F1_e(double c, double x, gsl_sf_result * result)
{
const double rintc = floor(c + 0.5);
const int c_neg_integer = (c < 0.0 && fabs(c - rintc) < locEPS);
/* CHECK_POINTER(result) */
if(c == 0.0 || c_neg_integer) {
DOMAIN_ERROR(result);
}
else if(x < 0.0) {
gsl_sf_result Jcm1;
gsl_sf_result lg_c;
double sgn;
int stat_g = gsl_sf_lngamma_sgn_e(c, &lg_c, &sgn);
int stat_J = hyperg_0F1_bessel_J(c-1.0, 2.0*sqrt(-x), &Jcm1);
if(stat_g != GSL_SUCCESS) {
result->val = 0.0;
result->err = 0.0;
return stat_g;
}
else if(Jcm1.val == 0.0) {
result->val = 0.0;
result->err = 0.0;
return stat_J;
}
else {
const double tl = log(-x)*0.5*(1.0-c);
double ln_pre_val = lg_c.val + tl;
double ln_pre_err = lg_c.err + 2.0 * GSL_DBL_EPSILON * fabs(tl);
return gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,
sgn*Jcm1.val, Jcm1.err,
result);
}
}
else if(x == 0.0) {
result->val = 1.0;
result->err = 1.0;
return GSL_SUCCESS;
}
else {
gsl_sf_result Icm1;
gsl_sf_result lg_c;
double sgn;
int stat_g = gsl_sf_lngamma_sgn_e(c, &lg_c, &sgn);
int stat_I = hyperg_0F1_bessel_I(c-1.0, 2.0*sqrt(x), &Icm1);
if(stat_g != GSL_SUCCESS) {
result->val = 0.0;
result->err = 0.0;
return stat_g;
}
else if(Icm1.val == 0.0) {
result->val = 0.0;
result->err = 0.0;
return stat_I;
}
else {
const double tl = log(x)*0.5*(1.0-c);
const double ln_pre_val = lg_c.val + tl;
const double ln_pre_err = lg_c.err + 2.0 * GSL_DBL_EPSILON * fabs(tl);
return gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,
sgn*Icm1.val, Icm1.err,
result);
}
}
}
int
gsl_sf_lnbeta_sgn_e(const double x, const double y, gsl_sf_result * result, double * sgn)
{
/* CHECK_POINTER(result) */
if(x == 0.0 || y == 0.0) {
*sgn = 0.0;
DOMAIN_ERROR(result);
} else if (isnegint(x) || isnegint(y)) {
*sgn = 0.0;
DOMAIN_ERROR(result); /* not defined for negative integers */
}
/* See if we can handle the postive case with min/max < 0.2 */
if (x > 0 && y > 0) {
const double max = GSL_MAX(x,y);
const double min = GSL_MIN(x,y);
const double rat = min/max;
if(rat < 0.2) {
/* min << max, so be careful
* with the subtraction
*/
double lnpre_val;
double lnpre_err;
double lnpow_val;
double lnpow_err;
double t1, t2, t3;
gsl_sf_result lnopr;
gsl_sf_result gsx, gsy, gsxy;
gsl_sf_gammastar_e(x, &gsx);
gsl_sf_gammastar_e(y, &gsy);
gsl_sf_gammastar_e(x+y, &gsxy);
gsl_sf_log_1plusx_e(rat, &lnopr);
lnpre_val = log(gsx.val*gsy.val/gsxy.val * M_SQRT2*M_SQRTPI);
lnpre_err = gsx.err/gsx.val + gsy.err/gsy.val + gsxy.err/gsxy.val;
t1 = min*log(rat);
t2 = 0.5*log(min);
t3 = (x+y-0.5)*lnopr.val;
lnpow_val = t1 - t2 - t3;
lnpow_err = GSL_DBL_EPSILON * (fabs(t1) + fabs(t2) + fabs(t3));
lnpow_err += fabs(x+y-0.5) * lnopr.err;
result->val = lnpre_val + lnpow_val;
result->err = lnpre_err + lnpow_err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*sgn = 1.0;
return GSL_SUCCESS;
}
}
/* General case - Fallback */
{
gsl_sf_result lgx, lgy, lgxy;
double sgx, sgy, sgxy, xy = x+y;
int stat_gx = gsl_sf_lngamma_sgn_e(x, &lgx, &sgx);
int stat_gy = gsl_sf_lngamma_sgn_e(y, &lgy, &sgy);
int stat_gxy = gsl_sf_lngamma_sgn_e(xy, &lgxy, &sgxy);
*sgn = sgx * sgy * sgxy;
result->val = lgx.val + lgy.val - lgxy.val;
result->err = lgx.err + lgy.err + lgxy.err;
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(lgx.val) + fabs(lgy.val) + fabs(lgxy.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_3(stat_gx, stat_gy, stat_gxy);
}
}
int
gsl_sf_lnpoch_sgn_e(const double a, const double x,
gsl_sf_result * result, double * sgn)
{
if(a == 0.0 || a+x == 0.0) {
*sgn = 0.0;
DOMAIN_ERROR(result);
}
else if(x == 0.0) {
*sgn = 1.0;
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(a > 0.0 && a+x > 0.0) {
*sgn = 1.0;
return lnpoch_pos(a, x, result);
}
else if(a < 0.0 && a+x < 0.0) {
/* Reduce to positive case using reflection.
*/
double sin_1 = sin(M_PI * (1.0 - a));
double sin_2 = sin(M_PI * (1.0 - a - x));
if(sin_1 == 0.0 || sin_2 == 0.0) {
*sgn = 0.0;
DOMAIN_ERROR(result);
}
else {
gsl_sf_result lnp_pos;
int stat_pp = lnpoch_pos(1.0-a, -x, &lnp_pos);
double lnterm = log(fabs(sin_1/sin_2));
result->val = lnterm - lnp_pos.val;
result->err = lnp_pos.err;
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(1.0-a) + fabs(1.0-a-x)) * fabs(lnterm);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*sgn = GSL_SIGN(sin_1*sin_2);
return stat_pp;
}
}
else {
/* Evaluate gamma ratio directly.
*/
gsl_sf_result lg_apn;
gsl_sf_result lg_a;
double s_apn, s_a;
int stat_apn = gsl_sf_lngamma_sgn_e(a+x, &lg_apn, &s_apn);
int stat_a = gsl_sf_lngamma_sgn_e(a, &lg_a, &s_a);
if(stat_apn == GSL_SUCCESS && stat_a == GSL_SUCCESS) {
result->val = lg_apn.val - lg_a.val;
result->err = lg_apn.err + lg_a.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*sgn = s_a * s_apn;
return GSL_SUCCESS;
}
else if(stat_apn == GSL_EDOM || stat_a == GSL_EDOM){
*sgn = 0.0;
DOMAIN_ERROR(result);
}
else {
result->val = 0.0;
result->err = 0.0;
*sgn = 0.0;
return GSL_FAILURE;
}
}
}
int
gsl_sf_hyperg_U_large_b_e(const double a, const double b, const double x,
gsl_sf_result * result,
double * ln_multiplier
)
{
double N = floor(b); /* b = N + eps */
double eps = b - N;
if(fabs(eps) < GSL_SQRT_DBL_EPSILON) {
double lnpre_val;
double lnpre_err;
gsl_sf_result M;
if(b > 1.0) {
double tmp = (1.0-b)*log(x);
gsl_sf_result lg_bm1;
gsl_sf_result lg_a;
gsl_sf_lngamma_e(b-1.0, &lg_bm1);
gsl_sf_lngamma_e(a, &lg_a);
lnpre_val = tmp + x + lg_bm1.val - lg_a.val;
lnpre_err = lg_bm1.err + lg_a.err + GSL_DBL_EPSILON * (fabs(x) + fabs(tmp));
gsl_sf_hyperg_1F1_large_b_e(1.0-a, 2.0-b, -x, &M);
}
else {
gsl_sf_result lg_1mb;
gsl_sf_result lg_1pamb;
gsl_sf_lngamma_e(1.0-b, &lg_1mb);
gsl_sf_lngamma_e(1.0+a-b, &lg_1pamb);
lnpre_val = lg_1mb.val - lg_1pamb.val;
lnpre_err = lg_1mb.err + lg_1pamb.err;
gsl_sf_hyperg_1F1_large_b_e(a, b, x, &M);
}
if(lnpre_val > GSL_LOG_DBL_MAX-10.0) {
result->val = M.val;
result->err = M.err;
*ln_multiplier = lnpre_val;
GSL_ERROR ("overflow", GSL_EOVRFLW);
}
else {
gsl_sf_result epre;
int stat_e = gsl_sf_exp_err_e(lnpre_val, lnpre_err, &epre);
result->val = epre.val * M.val;
result->err = epre.val * M.err + epre.err * fabs(M.val);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*ln_multiplier = 0.0;
return stat_e;
}
}
else {
double omb_lnx = (1.0-b)*log(x);
gsl_sf_result lg_1mb;
double sgn_1mb;
gsl_sf_result lg_1pamb;
double sgn_1pamb;
gsl_sf_result lg_bm1;
double sgn_bm1;
gsl_sf_result lg_a;
double sgn_a;
gsl_sf_result M1, M2;
double lnpre1_val, lnpre2_val;
double lnpre1_err, lnpre2_err;
double sgpre1, sgpre2;
gsl_sf_hyperg_1F1_large_b_e( a, b, x, &M1);
gsl_sf_hyperg_1F1_large_b_e(1.0-a, 2.0-b, x, &M2);
gsl_sf_lngamma_sgn_e(1.0-b, &lg_1mb, &sgn_1mb);
gsl_sf_lngamma_sgn_e(1.0+a-b, &lg_1pamb, &sgn_1pamb);
gsl_sf_lngamma_sgn_e(b-1.0, &lg_bm1, &sgn_bm1);
gsl_sf_lngamma_sgn_e(a, &lg_a, &sgn_a);
lnpre1_val = lg_1mb.val - lg_1pamb.val;
lnpre1_err = lg_1mb.err + lg_1pamb.err;
lnpre2_val = lg_bm1.val - lg_a.val - omb_lnx - x;
lnpre2_err = lg_bm1.err + lg_a.err + GSL_DBL_EPSILON * (fabs(omb_lnx)+fabs(x));
sgpre1 = sgn_1mb * sgn_1pamb;
sgpre2 = sgn_bm1 * sgn_a;
if(lnpre1_val > GSL_LOG_DBL_MAX-10.0 || lnpre2_val > GSL_LOG_DBL_MAX-10.0) {
double max_lnpre_val = GSL_MAX(lnpre1_val,lnpre2_val);
double max_lnpre_err = GSL_MAX(lnpre1_err,lnpre2_err);
double lp1 = lnpre1_val - max_lnpre_val;
double lp2 = lnpre2_val - max_lnpre_val;
double t1 = sgpre1*exp(lp1);
double t2 = sgpre2*exp(lp2);
result->val = t1*M1.val + t2*M2.val;
result->err = fabs(t1)*M1.err + fabs(t2)*M2.err;
result->err += GSL_DBL_EPSILON * exp(max_lnpre_err) * (fabs(t1*M1.val) + fabs(t2*M2.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*ln_multiplier = max_lnpre_val;
GSL_ERROR ("overflow", GSL_EOVRFLW);
}
else {
double t1 = sgpre1*exp(lnpre1_val);
double t2 = sgpre2*exp(lnpre2_val);
result->val = t1*M1.val + t2*M2.val;
result->err = fabs(t1) * M1.err + fabs(t2)*M2.err;
result->err += GSL_DBL_EPSILON * (exp(lnpre1_err)*fabs(t1*M1.val) + exp(lnpre2_err)*fabs(t2*M2.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
*ln_multiplier = 0.0;
return GSL_SUCCESS;
}
}
}
int
gsl_sf_hyperg_2F1_e(double a, double b, const double c,
const double x,
gsl_sf_result * result)
{
const double d = c - a - b;
const double rinta = floor(a + 0.5);
const double rintb = floor(b + 0.5);
const double rintc = floor(c + 0.5);
const int a_neg_integer = ( a < 0.0 && fabs(a - rinta) < locEPS );
const int b_neg_integer = ( b < 0.0 && fabs(b - rintb) < locEPS );
const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );
result->val = 0.0;
result->err = 0.0;
/* Handle x == 1.0 RJM */
if (fabs (x - 1.0) < locEPS && (c - a - b) > 0 && c != 0 && !c_neg_integer) {
gsl_sf_result lngamc, lngamcab, lngamca, lngamcb;
double lngamc_sgn, lngamca_sgn, lngamcb_sgn;
int status;
int stat1 = gsl_sf_lngamma_sgn_e (c, &lngamc, &lngamc_sgn);
int stat2 = gsl_sf_lngamma_e (c - a - b, &lngamcab);
int stat3 = gsl_sf_lngamma_sgn_e (c - a, &lngamca, &lngamca_sgn);
int stat4 = gsl_sf_lngamma_sgn_e (c - b, &lngamcb, &lngamcb_sgn);
if (stat1 != GSL_SUCCESS || stat2 != GSL_SUCCESS
|| stat3 != GSL_SUCCESS || stat4 != GSL_SUCCESS)
{
DOMAIN_ERROR (result);
}
status =
gsl_sf_exp_err_e (lngamc.val + lngamcab.val - lngamca.val - lngamcb.val,
lngamc.err + lngamcab.err + lngamca.err + lngamcb.err,
result);
result->val *= lngamc_sgn / (lngamca_sgn * lngamcb_sgn);
return status;
}
if(x < -1.0 || 1.0 <= x) {
DOMAIN_ERROR(result);
}
if(c_neg_integer) {
/* If c is a negative integer, then either a or b must be a
negative integer of smaller magnitude than c to ensure
cancellation of the series. */
if(! (a_neg_integer && a > c + 0.1) && ! (b_neg_integer && b > c + 0.1)) {
DOMAIN_ERROR(result);
}
}
if(fabs(c-b) < locEPS || fabs(c-a) < locEPS) {
return pow_omx(x, d, result); /* (1-x)^(c-a-b) */
}
if(a >= 0.0 && b >= 0.0 && c >=0.0 && x >= 0.0 && x < 0.995) {
/* Series has all positive definite
* terms and x is not close to 1.
*/
return hyperg_2F1_series(a, b, c, x, result);
}
if(fabs(a) < 10.0 && fabs(b) < 10.0) {
/* a and b are not too large, so we attempt
* variations on the series summation.
*/
if(a_neg_integer) {
return hyperg_2F1_series(rinta, b, c, x, result);
}
if(b_neg_integer) {
return hyperg_2F1_series(a, rintb, c, x, result);
}
if(x < -0.25) {
return hyperg_2F1_luke(a, b, c, x, result);
}
else if(x < 0.5) {
return hyperg_2F1_series(a, b, c, x, result);
}
else {
if(fabs(c) > 10.0) {
return hyperg_2F1_series(a, b, c, x, result);
}
else {
return hyperg_2F1_reflect(a, b, c, x, result);
}
}
}
else {
/* Either a or b or both large.
* Introduce some new variables ap,bp so that bp is
* the larger in magnitude.
*/
double ap, bp;
if(fabs(a) > fabs(b)) {
bp = a;
ap = b;
}
else {
bp = b;
ap = a;
}
if(x < 0.0) {
/* What the hell, maybe Luke will converge.
*/
return hyperg_2F1_luke(a, b, c, x, result);
}
if(GSL_MAX_DBL(fabs(a),1.0)*fabs(bp)*fabs(x) < 2.0*fabs(c)) {
/* If c is large enough or x is small enough,
* we can attempt the series anyway.
*/
return hyperg_2F1_series(a, b, c, x, result);
}
if(fabs(bp*bp*x*x) < 0.001*fabs(bp) && fabs(a) < 10.0) {
/* The famous but nearly worthless "large b" asymptotic.
*/
int stat = gsl_sf_hyperg_1F1_e(a, c, bp*x, result);
result->err = 0.001 * fabs(result->val);
return stat;
}
/* We give up. */
result->val = 0.0;
result->err = 0.0;
GSL_ERROR ("error", GSL_EUNIMPL);
}
}
/* Do the reflection described in [Moshier, p. 334].
* Assumes a,b,c != neg integer.
*/
static
int
hyperg_2F1_reflect(const double a, const double b, const double c,
const double x, gsl_sf_result * result)
{
const double d = c - a - b;
const int intd = floor(d+0.5);
const int d_integer = ( fabs(d - intd) < locEPS );
if(d_integer) {
const double ln_omx = log(1.0 - x);
const double ad = fabs(d);
int stat_F2 = GSL_SUCCESS;
double sgn_2;
gsl_sf_result F1;
gsl_sf_result F2;
double d1, d2;
gsl_sf_result lng_c;
gsl_sf_result lng_ad2;
gsl_sf_result lng_bd2;
int stat_c;
int stat_ad2;
int stat_bd2;
if(d >= 0.0) {
d1 = d;
d2 = 0.0;
}
else {
d1 = 0.0;
d2 = d;
}
stat_ad2 = gsl_sf_lngamma_e(a+d2, &lng_ad2);
stat_bd2 = gsl_sf_lngamma_e(b+d2, &lng_bd2);
stat_c = gsl_sf_lngamma_e(c, &lng_c);
/* Evaluate F1.
*/
if(ad < GSL_DBL_EPSILON) {
/* d = 0 */
F1.val = 0.0;
F1.err = 0.0;
}
else {
gsl_sf_result lng_ad;
gsl_sf_result lng_ad1;
gsl_sf_result lng_bd1;
int stat_ad = gsl_sf_lngamma_e(ad, &lng_ad);
int stat_ad1 = gsl_sf_lngamma_e(a+d1, &lng_ad1);
int stat_bd1 = gsl_sf_lngamma_e(b+d1, &lng_bd1);
if(stat_ad1 == GSL_SUCCESS && stat_bd1 == GSL_SUCCESS && stat_ad == GSL_SUCCESS) {
/* Gamma functions in the denominator are ok.
* Proceed with evaluation.
*/
int i;
double sum1 = 1.0;
double term = 1.0;
double ln_pre1_val = lng_ad.val + lng_c.val + d2*ln_omx - lng_ad1.val - lng_bd1.val;
double ln_pre1_err = lng_ad.err + lng_c.err + lng_ad1.err + lng_bd1.err + GSL_DBL_EPSILON * fabs(ln_pre1_val);
int stat_e;
/* Do F1 sum.
*/
for(i=1; i<ad; i++) {
int j = i-1;
term *= (a + d2 + j) * (b + d2 + j) / (1.0 + d2 + j) / i * (1.0-x);
sum1 += term;
}
stat_e = gsl_sf_exp_mult_err_e(ln_pre1_val, ln_pre1_err,
sum1, GSL_DBL_EPSILON*fabs(sum1),
&F1);
if(stat_e == GSL_EOVRFLW) {
OVERFLOW_ERROR(result);
}
}
else {
/* Gamma functions in the denominator were not ok.
* So the F1 term is zero.
*/
F1.val = 0.0;
F1.err = 0.0;
}
} /* end F1 evaluation */
/* Evaluate F2.
*/
if(stat_ad2 == GSL_SUCCESS && stat_bd2 == GSL_SUCCESS) {
/* Gamma functions in the denominator are ok.
* Proceed with evaluation.
*/
const int maxiter = 2000;
double psi_1 = -M_EULER;
gsl_sf_result psi_1pd;
gsl_sf_result psi_apd1;
gsl_sf_result psi_bpd1;
int stat_1pd = gsl_sf_psi_e(1.0 + ad, &psi_1pd);
int stat_apd1 = gsl_sf_psi_e(a + d1, &psi_apd1);
int stat_bpd1 = gsl_sf_psi_e(b + d1, &psi_bpd1);
int stat_dall = GSL_ERROR_SELECT_3(stat_1pd, stat_apd1, stat_bpd1);
double psi_val = psi_1 + psi_1pd.val - psi_apd1.val - psi_bpd1.val - ln_omx;
double psi_err = psi_1pd.err + psi_apd1.err + psi_bpd1.err + GSL_DBL_EPSILON*fabs(psi_val);
double fact = 1.0;
double sum2_val = psi_val;
double sum2_err = psi_err;
double ln_pre2_val = lng_c.val + d1*ln_omx - lng_ad2.val - lng_bd2.val;
double ln_pre2_err = lng_c.err + lng_ad2.err + lng_bd2.err + GSL_DBL_EPSILON * fabs(ln_pre2_val);
int stat_e;
int j;
/* Do F2 sum.
*/
for(j=1; j<maxiter; j++) {
/* values for psi functions use recurrence; Abramowitz+Stegun 6.3.5 */
double term1 = 1.0/(double)j + 1.0/(ad+j);
double term2 = 1.0/(a+d1+j-1.0) + 1.0/(b+d1+j-1.0);
double delta = 0.0;
psi_val += term1 - term2;
psi_err += GSL_DBL_EPSILON * (fabs(term1) + fabs(term2));
fact *= (a+d1+j-1.0)*(b+d1+j-1.0)/((ad+j)*j) * (1.0-x);
delta = fact * psi_val;
sum2_val += delta;
sum2_err += fabs(fact * psi_err) + GSL_DBL_EPSILON*fabs(delta);
if(fabs(delta) < GSL_DBL_EPSILON * fabs(sum2_val)) break;
}
if(j == maxiter) stat_F2 = GSL_EMAXITER;
if(sum2_val == 0.0) {
F2.val = 0.0;
F2.err = 0.0;
}
else {
stat_e = gsl_sf_exp_mult_err_e(ln_pre2_val, ln_pre2_err,
sum2_val, sum2_err,
&F2);
if(stat_e == GSL_EOVRFLW) {
result->val = 0.0;
result->err = 0.0;
GSL_ERROR ("error", GSL_EOVRFLW);
}
}
stat_F2 = GSL_ERROR_SELECT_2(stat_F2, stat_dall);
}
else {
/* Gamma functions in the denominator not ok.
* So the F2 term is zero.
*/
F2.val = 0.0;
F2.err = 0.0;
} /* end F2 evaluation */
sgn_2 = ( GSL_IS_ODD(intd) ? -1.0 : 1.0 );
result->val = F1.val + sgn_2 * F2.val;
result->err = F1.err + F2. err;
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(F1.val) + fabs(F2.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_F2;
}
else {
/* d not an integer */
gsl_sf_result pre1, pre2;
double sgn1, sgn2;
gsl_sf_result F1, F2;
int status_F1, status_F2;
/* These gamma functions appear in the denominator, so we
* catch their harmless domain errors and set the terms to zero.
*/
gsl_sf_result ln_g1ca, ln_g1cb, ln_g2a, ln_g2b;
double sgn_g1ca, sgn_g1cb, sgn_g2a, sgn_g2b;
int stat_1ca = gsl_sf_lngamma_sgn_e(c-a, &ln_g1ca, &sgn_g1ca);
int stat_1cb = gsl_sf_lngamma_sgn_e(c-b, &ln_g1cb, &sgn_g1cb);
int stat_2a = gsl_sf_lngamma_sgn_e(a, &ln_g2a, &sgn_g2a);
int stat_2b = gsl_sf_lngamma_sgn_e(b, &ln_g2b, &sgn_g2b);
int ok1 = (stat_1ca == GSL_SUCCESS && stat_1cb == GSL_SUCCESS);
int ok2 = (stat_2a == GSL_SUCCESS && stat_2b == GSL_SUCCESS);
gsl_sf_result ln_gc, ln_gd, ln_gmd;
double sgn_gc, sgn_gd, sgn_gmd;
gsl_sf_lngamma_sgn_e( c, &ln_gc, &sgn_gc);
gsl_sf_lngamma_sgn_e( d, &ln_gd, &sgn_gd);
gsl_sf_lngamma_sgn_e(-d, &ln_gmd, &sgn_gmd);
sgn1 = sgn_gc * sgn_gd * sgn_g1ca * sgn_g1cb;
sgn2 = sgn_gc * sgn_gmd * sgn_g2a * sgn_g2b;
if(ok1 && ok2) {
double ln_pre1_val = ln_gc.val + ln_gd.val - ln_g1ca.val - ln_g1cb.val;
double ln_pre2_val = ln_gc.val + ln_gmd.val - ln_g2a.val - ln_g2b.val + d*log(1.0-x);
double ln_pre1_err = ln_gc.err + ln_gd.err + ln_g1ca.err + ln_g1cb.err;
double ln_pre2_err = ln_gc.err + ln_gmd.err + ln_g2a.err + ln_g2b.err;
if(ln_pre1_val < GSL_LOG_DBL_MAX && ln_pre2_val < GSL_LOG_DBL_MAX) {
gsl_sf_exp_err_e(ln_pre1_val, ln_pre1_err, &pre1);
gsl_sf_exp_err_e(ln_pre2_val, ln_pre2_err, &pre2);
pre1.val *= sgn1;
pre2.val *= sgn2;
}
else {
OVERFLOW_ERROR(result);
}
}
else if(ok1 && !ok2) {
double ln_pre1_val = ln_gc.val + ln_gd.val - ln_g1ca.val - ln_g1cb.val;
double ln_pre1_err = ln_gc.err + ln_gd.err + ln_g1ca.err + ln_g1cb.err;
if(ln_pre1_val < GSL_LOG_DBL_MAX) {
gsl_sf_exp_err_e(ln_pre1_val, ln_pre1_err, &pre1);
pre1.val *= sgn1;
pre2.val = 0.0;
pre2.err = 0.0;
}
else {
OVERFLOW_ERROR(result);
}
}
else if(!ok1 && ok2) {
double ln_pre2_val = ln_gc.val + ln_gmd.val - ln_g2a.val - ln_g2b.val + d*log(1.0-x);
double ln_pre2_err = ln_gc.err + ln_gmd.err + ln_g2a.err + ln_g2b.err;
if(ln_pre2_val < GSL_LOG_DBL_MAX) {
pre1.val = 0.0;
pre1.err = 0.0;
gsl_sf_exp_err_e(ln_pre2_val, ln_pre2_err, &pre2);
pre2.val *= sgn2;
}
else {
OVERFLOW_ERROR(result);
}
}
else {
pre1.val = 0.0;
pre2.val = 0.0;
UNDERFLOW_ERROR(result);
}
status_F1 = hyperg_2F1_series( a, b, 1.0-d, 1.0-x, &F1);
status_F2 = hyperg_2F1_series(c-a, c-b, 1.0+d, 1.0-x, &F2);
result->val = pre1.val*F1.val + pre2.val*F2.val;
result->err = fabs(pre1.val*F1.err) + fabs(pre2.val*F2.err);
result->err += fabs(pre1.err*F1.val) + fabs(pre2.err*F2.val);
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(pre1.val*F1.val) + fabs(pre2.val*F2.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}