int gsl_sf_eta_e(const double s, gsl_sf_result * result) { /* CHECK_POINTER(result) */ if(s > 100.0) { result->val = 1.0; result->err = GSL_DBL_EPSILON; return GSL_SUCCESS; } else if(fabs(s-1.0) < 10.0*GSL_ROOT5_DBL_EPSILON) { double del = s-1.0; double c0 = M_LN2; double c1 = M_LN2 * (M_EULER - 0.5*M_LN2); double c2 = -0.0326862962794492996; double c3 = 0.0015689917054155150; double c4 = 0.00074987242112047532; result->val = c0 + del * (c1 + del * (c2 + del * (c3 + del * c4))); result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_SUCCESS; } else { gsl_sf_result z; gsl_sf_result p; int stat_z = gsl_sf_zeta_e(s, &z); int stat_p = gsl_sf_exp_e((1.0-s)*M_LN2, &p); int stat_m = gsl_sf_multiply_e(1.0-p.val, z.val, result); result->err = fabs(p.err * (M_LN2*(1.0-s)) * z.val) + z.err * fabs(p.val); result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_m, stat_p, stat_z); } }
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); } }
int gsl_sf_psi_n_e(const int n, const double x, gsl_sf_result * result) { /* CHECK_POINTER(result) */ if(n == 0) { return gsl_sf_psi_e(x, result); } else if(n == 1) { return gsl_sf_psi_1_e(x, result); } else if(n < 0 || x <= 0.0) { DOMAIN_ERROR(result); } else { gsl_sf_result ln_nf; gsl_sf_result hzeta; int stat_hz = gsl_sf_hzeta_e(n+1.0, x, &hzeta); int stat_nf = gsl_sf_lnfact_e((unsigned int) n, &ln_nf); int stat_e = gsl_sf_exp_mult_err_e(ln_nf.val, ln_nf.err, hzeta.val, hzeta.err, result); if(GSL_IS_EVEN(n)) result->val = -result->val; return GSL_ERROR_SELECT_3(stat_e, stat_nf, stat_hz); } }
int gsl_sf_bessel_J0_e(const double x, gsl_sf_result * result) { double y = fabs(x); /* CHECK_POINTER(result) */ if(y < 2.0*GSL_SQRT_DBL_EPSILON) { result->val = 1.0; result->err = y*y; return GSL_SUCCESS; } else if(y <= 4.0) { return cheb_eval_e(&bj0_cs, 0.125*y*y - 1.0, result); } else { const double z = 32.0/(y*y) - 1.0; gsl_sf_result ca; gsl_sf_result ct; gsl_sf_result cp; const int stat_ca = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bm0_cs, z, &ca); const int stat_ct = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bth0_cs, z, &ct); const int stat_cp = gsl_sf_bessel_cos_pi4_e(y, ct.val/y, &cp); const double sqrty = sqrt(y); const double ampl = (0.75 + ca.val) / sqrty; result->val = ampl * cp.val; result->err = fabs(cp.val) * ca.err/sqrty + fabs(ampl) * cp.err; result->err += GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_ca, stat_ct, stat_cp); } }
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); } }
int gsl_sf_bessel_Y1_e(const double x, gsl_sf_result * result) { const double two_over_pi = 2.0/M_PI; const double xmin = 1.571*GSL_DBL_MIN; /*exp ( amax1(alog(r1mach(1)), -alog(r1mach(2)))+.01) */ const double x_small = 2.0 * GSL_SQRT_DBL_EPSILON; const double xmax = 1.0/GSL_DBL_EPSILON; /* CHECK_POINTER(result) */ if(x <= 0.0) { DOMAIN_ERROR(result); } else if(x < xmin) { OVERFLOW_ERROR(result); } else if(x < x_small) { const double lnterm = log(0.5*x); gsl_sf_result J1; gsl_sf_result c; int status = gsl_sf_bessel_J1_e(x, &J1); cheb_eval_e(&by1_cs, -1.0, &c); result->val = two_over_pi * lnterm * J1.val + (0.5 + c.val)/x; result->err = fabs(lnterm) * (fabs(GSL_DBL_EPSILON * J1.val) + J1.err) + c.err/x; return status; } else if(x < 4.0) { const double lnterm = log(0.5*x); int status; gsl_sf_result J1; gsl_sf_result c; cheb_eval_e(&by1_cs, 0.125*x*x-1.0, &c); status = gsl_sf_bessel_J1_e(x, &J1); result->val = two_over_pi * lnterm * J1.val + (0.5 + c.val)/x; result->err = fabs(lnterm) * (fabs(GSL_DBL_EPSILON * J1.val) + J1.err) + c.err/x; return status; } else if(x < xmax) { const double z = 32.0/(x*x) - 1.0; gsl_sf_result ca; gsl_sf_result ct; gsl_sf_result cp; const int stat_ca = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bm1_cs, z, &ca); const int stat_ct = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bth1_cs, z, &ct); const int stat_cp = gsl_sf_bessel_cos_pi4_e(x, ct.val/x, &cp); const double sqrtx = sqrt(x); const double ampl = (0.75 + ca.val) / sqrtx; result->val = -ampl * cp.val; result->err = fabs(cp.val) * ca.err/sqrtx + fabs(ampl) * cp.err; result->err += GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_ca, stat_ct, stat_cp); } else { UNDERFLOW_ERROR(result); } }
/* asymptotic expansion * j + 2.0 > 0.0 */ static int fd_asymp(const double j, const double x, gsl_sf_result * result) { const int j_integer = ( fabs(j - floor(j+0.5)) < 100.0*GSL_DBL_EPSILON ); const int itmax = 200; gsl_sf_result lg; int stat_lg = gsl_sf_lngamma_e(j + 2.0, &lg); double seqn_val = 0.5; double seqn_err = 0.0; double xm2 = (1.0/x)/x; double xgam = 1.0; double add = GSL_DBL_MAX; double cos_term; double ln_x; double ex_term_1; double ex_term_2; gsl_sf_result fneg; gsl_sf_result ex_arg; gsl_sf_result ex; int stat_fneg; int stat_e; int n; for(n=1; n<=itmax; n++) { double add_previous = add; gsl_sf_result eta; gsl_sf_eta_int_e(2*n, &eta); xgam = xgam * xm2 * (j + 1.0 - (2*n-2)) * (j + 1.0 - (2*n-1)); add = eta.val * xgam; if(!j_integer && fabs(add) > fabs(add_previous)) break; if(fabs(add/seqn_val) < GSL_DBL_EPSILON) break; seqn_val += add; seqn_err += 2.0 * GSL_DBL_EPSILON * fabs(add); } seqn_err += fabs(add); stat_fneg = fd_neg(j, -x, &fneg); ln_x = log(x); ex_term_1 = (j+1.0)*ln_x; ex_term_2 = lg.val; ex_arg.val = ex_term_1 - ex_term_2; /*(j+1.0)*ln_x - lg.val; */ ex_arg.err = GSL_DBL_EPSILON*(fabs(ex_term_1) + fabs(ex_term_2)) + lg.err; stat_e = gsl_sf_exp_err_e(ex_arg.val, ex_arg.err, &ex); cos_term = cos(j*M_PI); result->val = cos_term * fneg.val + 2.0 * seqn_val * ex.val; result->err = fabs(2.0 * ex.err * seqn_val); result->err += fabs(2.0 * ex.val * seqn_err); result->err += fabs(cos_term) * fneg.err; result->err += 4.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_e, stat_fneg, stat_lg); }
int gsl_sf_bessel_J1_e(const double x, gsl_sf_result * result) { double y = fabs(x); /* CHECK_POINTER(result) */ if(y == 0.0) { result->val = 0.0; result->err = 0.0; return GSL_SUCCESS; } else if(y < 2.0*GSL_DBL_MIN) { UNDERFLOW_ERROR(result); } else if(y < ROOT_EIGHT * GSL_SQRT_DBL_EPSILON) { result->val = 0.5*x; result->err = 0.0; return GSL_SUCCESS; } else if(y < 4.0) { gsl_sf_result c; cheb_eval_e(&bj1_cs, 0.125*y*y-1.0, &c); result->val = x * (0.25 + c.val); result->err = fabs(x * c.err); return GSL_SUCCESS; } else { /* Because the leading term in the phase is y, * which we assume is exactly known, the error * in the cos() evaluation is bounded. */ const double z = 32.0/(y*y) - 1.0; gsl_sf_result ca; gsl_sf_result ct; gsl_sf_result sp; const int stat_ca = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bm1_cs, z, &ca); const int stat_ct = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bth1_cs, z, &ct); const int stat_sp = gsl_sf_bessel_sin_pi4_e(y, ct.val/y, &sp); const double sqrty = sqrt(y); const double ampl = (0.75 + ca.val) / sqrty; result->val = (x < 0.0 ? -ampl : ampl) * sp.val; result->err = fabs(sp.val) * ca.err/sqrty + fabs(ampl) * sp.err; result->err += GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_ca, stat_ct, stat_sp); } }
/* normalization for hydrogenic wave functions */ static int R_norm(const int n, const int l, const double Z, gsl_sf_result * result) { double A = 2.0*Z/n; double pre = sqrt(A*A*A /(2.0*n)); gsl_sf_result ln_a, ln_b; gsl_sf_result ex; int stat_a = gsl_sf_lnfact_e(n+l, &ln_a); int stat_b = gsl_sf_lnfact_e(n-l-1, &ln_b); double diff_val = 0.5*(ln_b.val - ln_a.val); double diff_err = 0.5*(ln_b.err + ln_a.err) + GSL_DBL_EPSILON * fabs(diff_val); int stat_e = gsl_sf_exp_err_e(diff_val, diff_err, &ex); result->val = pre * ex.val; result->err = pre * ex.err; result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_e, stat_a, stat_b); }
/* generic polygamma; assumes n >= 0 and x > 0 */ static int psi_n_xg0(const int n, const double x, gsl_sf_result * result) { if(n == 0) { return gsl_sf_psi_e(x, result); } else { /* Abramowitz + Stegun 6.4.10 */ gsl_sf_result ln_nf; gsl_sf_result hzeta; int stat_hz = gsl_sf_hzeta_e(n+1.0, x, &hzeta); int stat_nf = gsl_sf_lnfact_e((unsigned int) n, &ln_nf); int stat_e = gsl_sf_exp_mult_err_e(ln_nf.val, ln_nf.err, hzeta.val, hzeta.err, result); if(GSL_IS_EVEN(n)) result->val = -result->val; return GSL_ERROR_SELECT_3(stat_e, stat_nf, stat_hz); } }
int gsl_sf_bessel_Y0_e(const double x, gsl_sf_result * result) { const double two_over_pi = 2.0/M_PI; const double xmax = 1.0/GSL_DBL_EPSILON; /* CHECK_POINTER(result) */ if (x <= 0.0) { DOMAIN_ERROR(result); } else if(x < 4.0) { gsl_sf_result J0; gsl_sf_result c; int stat_J0 = gsl_sf_bessel_J0_e(x, &J0); cheb_eval_e(&by0_cs, 0.125*x*x-1.0, &c); result->val = two_over_pi*(-M_LN2 + log(x))*J0.val + 0.375 + c.val; result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val) + c.err; return stat_J0; } else if(x < xmax) { /* Leading behaviour of phase is x, which is exact, * so the error is bounded. */ const double z = 32.0/(x*x) - 1.0; gsl_sf_result c1; gsl_sf_result c2; gsl_sf_result sp; const int stat_c1 = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bm0_cs, z, &c1); const int stat_c2 = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bth0_cs, z, &c2); const int stat_sp = gsl_sf_bessel_sin_pi4_e(x, c2.val/x, &sp); const double sqrtx = sqrt(x); const double ampl = (0.75 + c1.val) / sqrtx; result->val = ampl * sp.val; result->err = fabs(sp.val) * c1.err/sqrtx + fabs(ampl) * sp.err; result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_sp, stat_c1, stat_c2); } else { UNDERFLOW_ERROR(result); } }
int gsl_sf_eta_int_e(int n, gsl_sf_result * result) { if(n > ETA_POS_TABLE_NMAX) { result->val = 1.0; result->err = GSL_DBL_EPSILON; return GSL_SUCCESS; } else if(n >= 0) { result->val = eta_pos_int_table[n]; result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_SUCCESS; } else { /* n < 0 */ if(!GSL_IS_ODD(n)) { /* exactly zero at even negative integers */ result->val = 0.0; result->err = 0.0; return GSL_SUCCESS; } else if(n > -ETA_NEG_TABLE_NMAX) { result->val = eta_neg_int_table[-(n+1)/2]; result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_SUCCESS; } else { gsl_sf_result z; gsl_sf_result p; int stat_z = gsl_sf_zeta_int_e(n, &z); int stat_p = gsl_sf_exp_e((1.0-n)*M_LN2, &p); int stat_m = gsl_sf_multiply_e(-p.val, z.val, result); result->err = fabs(p.err * (M_LN2*(1.0-n)) * z.val) + z.err * fabs(p.val); result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_m, stat_p, stat_z); } } }
/* 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; } }
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_bessel_IJ_taylor_e(const double nu, const double x, const int sign, const int kmax, const double threshold, gsl_sf_result * result ) { /* CHECK_POINTER(result) */ if(nu < 0.0 || x < 0.0) { DOMAIN_ERROR(result); } else if(x == 0.0) { if(nu == 0.0) { result->val = 1.0; result->err = 0.0; } else { result->val = 0.0; result->err = 0.0; } return GSL_SUCCESS; } else { gsl_sf_result prefactor; /* (x/2)^nu / Gamma(nu+1) */ gsl_sf_result sum; int stat_pre; int stat_sum; int stat_mul; if(nu == 0.0) { prefactor.val = 1.0; prefactor.err = 0.0; stat_pre = GSL_SUCCESS; } else if(nu < INT_MAX-1) { /* Separate the integer part and use * y^nu / Gamma(nu+1) = y^N /N! y^f / (N+1)_f, * to control the error. */ const int N = (int)floor(nu + 0.5); const double f = nu - N; gsl_sf_result poch_factor; gsl_sf_result tc_factor; const int stat_poch = gsl_sf_poch_e(N+1.0, f, &poch_factor); const int stat_tc = gsl_sf_taylorcoeff_e(N, 0.5*x, &tc_factor); const double p = pow(0.5*x,f); prefactor.val = tc_factor.val * p / poch_factor.val; prefactor.err = tc_factor.err * p / poch_factor.val; prefactor.err += fabs(prefactor.val) / poch_factor.val * poch_factor.err; prefactor.err += 2.0 * GSL_DBL_EPSILON * fabs(prefactor.val); stat_pre = GSL_ERROR_SELECT_2(stat_tc, stat_poch); } else { gsl_sf_result lg; const int stat_lg = gsl_sf_lngamma_e(nu+1.0, &lg); const double term1 = nu*log(0.5*x); const double term2 = lg.val; const double ln_pre = term1 - term2; const double ln_pre_err = GSL_DBL_EPSILON * (fabs(term1)+fabs(term2)) + lg.err; const int stat_ex = gsl_sf_exp_err_e(ln_pre, ln_pre_err, &prefactor); stat_pre = GSL_ERROR_SELECT_2(stat_ex, stat_lg); } /* Evaluate the sum. * [Abramowitz+Stegun, 9.1.10] * [Abramowitz+Stegun, 9.6.7] */ { const double y = sign * 0.25 * x*x; double sumk = 1.0; double term = 1.0; int k; for(k=1; k<=kmax; k++) { term *= y/((nu+k)*k); sumk += term; if(fabs(term/sumk) < threshold) break; } sum.val = sumk; sum.err = threshold * fabs(sumk); stat_sum = ( k >= kmax ? GSL_EMAXITER : GSL_SUCCESS ); } stat_mul = gsl_sf_multiply_err_e(prefactor.val, prefactor.err, sum.val, sum.err, result); return GSL_ERROR_SELECT_3(stat_mul, stat_pre, stat_sum); } }
/* series of hypergeometric functions for integer j > 0, x > 0 * [Goano (7)] */ static int fd_UMseries_int(const int j, const double x, gsl_sf_result * result) { const int nmax = 2000; double pre; double lnpre_val; double lnpre_err; double sum_even_val = 1.0; double sum_even_err = 0.0; double sum_odd_val = 0.0; double sum_odd_err = 0.0; int stat_sum; int stat_e; int stat_h = GSL_SUCCESS; int n; if(x < 500.0 && j < 80) { double p = gsl_sf_pow_int(x, j+1); gsl_sf_result g; gsl_sf_fact_e(j+1, &g); /* Gamma(j+2) */ lnpre_val = 0.0; lnpre_err = 0.0; pre = p/g.val; } else { double lnx = log(x); gsl_sf_result lg; gsl_sf_lngamma_e(j + 2.0, &lg); lnpre_val = (j+1.0)*lnx - lg.val; lnpre_err = 2.0 * GSL_DBL_EPSILON * fabs((j+1.0)*lnx) + lg.err; pre = 1.0; } /* Add up the odd terms of the sum. */ for(n=1; n<nmax; n+=2) { double del_val; double del_err; gsl_sf_result U; gsl_sf_result M; int stat_h_U = gsl_sf_hyperg_U_int_e(1, j+2, n*x, &U); int stat_h_F = gsl_sf_hyperg_1F1_int_e(1, j+2, -n*x, &M); stat_h = GSL_ERROR_SELECT_3(stat_h, stat_h_U, stat_h_F); del_val = ((j+1.0)*U.val - M.val); del_err = (fabs(j+1.0)*U.err + M.err); sum_odd_val += del_val; sum_odd_err += del_err; if(fabs(del_val/sum_odd_val) < GSL_DBL_EPSILON) break; } /* Add up the even terms of the sum. */ for(n=2; n<nmax; n+=2) { double del_val; double del_err; gsl_sf_result U; gsl_sf_result M; int stat_h_U = gsl_sf_hyperg_U_int_e(1, j+2, n*x, &U); int stat_h_F = gsl_sf_hyperg_1F1_int_e(1, j+2, -n*x, &M); stat_h = GSL_ERROR_SELECT_3(stat_h, stat_h_U, stat_h_F); del_val = ((j+1.0)*U.val - M.val); del_err = (fabs(j+1.0)*U.err + M.err); sum_even_val -= del_val; sum_even_err += del_err; if(fabs(del_val/sum_even_val) < GSL_DBL_EPSILON) break; } stat_sum = ( n >= nmax ? GSL_EMAXITER : GSL_SUCCESS ); stat_e = gsl_sf_exp_mult_err_e(lnpre_val, lnpre_err, pre*(sum_even_val + sum_odd_val), pre*(sum_even_err + sum_odd_err), result); result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val); return GSL_ERROR_SELECT_3(stat_e, stat_h, stat_sum); }
int gsl_sf_beta_inc_e( const double a, const double b, const double x, gsl_sf_result * result ) { if(a <= 0.0 || b <= 0.0 || x < 0.0 || x > 1.0) { DOMAIN_ERROR(result); } else if(x == 0.0) { result->val = 0.0; result->err = 0.0; return GSL_SUCCESS; } else if(x == 1.0) { result->val = 1.0; result->err = 0.0; return GSL_SUCCESS; } else { gsl_sf_result ln_beta; gsl_sf_result ln_x; gsl_sf_result ln_1mx; gsl_sf_result prefactor; const int stat_ln_beta = gsl_sf_lnbeta_e(a, b, &ln_beta); const int stat_ln_1mx = gsl_sf_log_1plusx_e(-x, &ln_1mx); const int stat_ln_x = gsl_sf_log_e(x, &ln_x); const int stat_ln = GSL_ERROR_SELECT_3(stat_ln_beta, stat_ln_1mx, stat_ln_x); const double ln_pre_val = -ln_beta.val + a * ln_x.val + b * ln_1mx.val; const double ln_pre_err = ln_beta.err + fabs(a*ln_x.err) + fabs(b*ln_1mx.err); const int stat_exp = gsl_sf_exp_err_e(ln_pre_val, ln_pre_err, &prefactor); if(stat_ln != GSL_SUCCESS) { result->val = 0.0; result->err = 0.0; GSL_ERROR ("error", GSL_ESANITY); } if(x < (a + 1.0)/(a+b+2.0)) { /* Apply continued fraction directly. */ gsl_sf_result cf; const int stat_cf = beta_cont_frac(a, b, x, &cf); int stat; result->val = prefactor.val * cf.val / a; result->err = (fabs(prefactor.err * cf.val) + fabs(prefactor.val * cf.err))/a; stat = GSL_ERROR_SELECT_2(stat_exp, stat_cf); if(stat == GSL_SUCCESS) { CHECK_UNDERFLOW(result); } return stat; } else { /* Apply continued fraction after hypergeometric transformation. */ gsl_sf_result cf; const int stat_cf = beta_cont_frac(b, a, 1.0-x, &cf); int stat; const double term = prefactor.val * cf.val / b; result->val = 1.0 - term; result->err = fabs(prefactor.err * cf.val)/b; result->err += fabs(prefactor.val * cf.err)/b; result->err += 2.0 * GSL_DBL_EPSILON * (1.0 + fabs(term)); stat = GSL_ERROR_SELECT_2(stat_exp, stat_cf); if(stat == GSL_SUCCESS) { CHECK_UNDERFLOW(result); } return stat; } } }