static
int expint_E2_impl(const double x, gsl_sf_result * result, const int scale)
{
const double xmaxt = -GSL_LOG_DBL_MIN;
const double xmax = xmaxt - log(xmaxt);
/* CHECK_POINTER(result) */
if(x < -xmax && !scale) {
OVERFLOW_ERROR(result);
}
else if (x == 0.0) {
result->val = 1.0;
result->err = 0.0;
return GSL_SUCCESS;
} else if(x < 100.0) {
const double ex = ( scale ? 1.0 : exp(-x) );
gsl_sf_result result_E1;
int stat_E1 = expint_E1_impl(x, &result_E1, scale);
result->val = ex - x*result_E1.val;
result->err = GSL_DBL_EPSILON*ex + fabs(x) * result_E1.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_E1;
}
else if(x < xmax || scale) {
const double s = ( scale ? 1.0 : exp(-x) );
const double c1 = -2.0;
const double c2 = 6.0;
const double c3 = -24.0;
const double c4 = 120.0;
const double c5 = -720.0;
const double c6 = 5040.0;
const double c7 = -40320.0;
const double c8 = 362880.0;
const double c9 = -3628800.0;
const double c10 = 39916800.0;
const double c11 = -479001600.0;
const double c12 = 6227020800.0;
const double c13 = -87178291200.0;
const double y = 1.0/x;
const double sum6 = c6+y*(c7+y*(c8+y*(c9+y*(c10+y*(c11+y*(c12+y*c13))))));
const double sum = y*(c1+y*(c2+y*(c3+y*(c4+y*(c5+y*sum6)))));
result->val = s * (1.0 + sum)/x;
result->err = 2.0 * (x + 1.0) * GSL_DBL_EPSILON * result->val;
if(result->val == 0.0)
UNDERFLOW_ERROR(result);
else
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_bessel_i2_scaled_e(const double x, gsl_sf_result * result)
{
double ax = fabs(x);
/* CHECK_POINTER(result) */
if(ax < 4.0*GSL_SQRT_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(ax < 0.25) {
const double y = x*x;
const double c1 = 1.0/14.0;
const double c2 = 1.0/504.0;
const double c3 = 1.0/33264.0;
const double c4 = 1.0/3459456.0;
const double c5 = 1.0/518918400.0;
const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));
const double pre = exp(-ax) * x*x/15.0;
result->val = pre * sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
double ex = exp(-2.0*ax);
double x2 = x*x;
result->val = 0.5 * ((3.0+x2)*(1.0-ex) - 3.0*ax*(1.0+ex))/(ax*ax*ax);
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
int gsl_sf_bessel_i1_scaled_e(const double x, gsl_sf_result * result)
{
double ax = fabs(x);
/* CHECK_POINTER(result) */
if(ax < 3.0*GSL_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(ax < 0.25) {
const double eax = exp(-ax);
const double y = x*x;
const double c1 = 1.0/10.0;
const double c2 = 1.0/280.0;
const double c3 = 1.0/15120.0;
const double c4 = 1.0/1330560.0;
const double c5 = 1.0/172972800.0;
const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));
result->val = eax * x/3.0 * sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
double ex = exp(-2.0*ax);
result->val = 0.5 * (ax*(1.0+ex) - (1.0-ex)) / (ax*ax);
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
if(x < 0.0) result->val = -result->val;
return GSL_SUCCESS;
}
}
int gsl_sf_hzeta_e(const double s, const double q, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(s <= 1.0 || q <= 0.0) {
DOMAIN_ERROR(result);
}
else {
const double max_bits = 54.0;
const double ln_term0 = -s * log(q);
if(ln_term0 < GSL_LOG_DBL_MIN + 1.0) {
UNDERFLOW_ERROR(result);
}
else if(ln_term0 > GSL_LOG_DBL_MAX - 1.0) {
OVERFLOW_ERROR (result);
}
else if((s > max_bits && q < 1.0) || (s > 0.5*max_bits && q < 0.25)) {
result->val = pow(q, -s);
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(s > 0.5*max_bits && q < 1.0) {
const double p1 = pow(q, -s);
const double p2 = pow(q/(1.0+q), s);
const double p3 = pow(q/(2.0+q), s);
result->val = p1 * (1.0 + p2 + p3);
result->err = GSL_DBL_EPSILON * (0.5*s + 2.0) * fabs(result->val);
return GSL_SUCCESS;
}
else {
/* Euler-Maclaurin summation formula
* [Moshier, p. 400, with several typo corrections]
*/
const int jmax = 12;
const int kmax = 10;
int j, k;
const double pmax = pow(kmax + q, -s);
double scp = s;
double pcp = pmax / (kmax + q);
double ans = pmax*((kmax+q)/(s-1.0) + 0.5);
for(k=0; k<kmax; k++) {
ans += pow(k + q, -s);
}
for(j=0; j<=jmax; j++) {
double delta = hzeta_c[j+1] * scp * pcp;
ans += delta;
if(fabs(delta/ans) < 0.5*GSL_DBL_EPSILON) break;
scp *= (s+2*j+1)*(s+2*j+2);
pcp /= (kmax + q)*(kmax + q);
}
result->val = ans;
result->err = 2.0 * (jmax + 1.0) * GSL_DBL_EPSILON * fabs(ans);
return GSL_SUCCESS;
}
}
}
int gsl_sf_fermi_dirac_2_e(const double x, gsl_sf_result * result)
{
if(x < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(x < -1.0) {
/* series [Goano (6)]
*/
double ex = exp(x);
double term = ex;
double sum = term;
int n;
for(n=2; n<100 ; n++) {
double rat = (n-1.0)/n;
term *= -ex * rat * rat * rat;
sum += term;
if(fabs(term/sum) < GSL_DBL_EPSILON) break;
}
result->val = sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(sum);
return GSL_SUCCESS;
}
else if(x < 1.0) {
return cheb_eval_e(&fd_2_a_cs, x, result);
}
else if(x < 4.0) {
double t = 2.0/3.0*(x-1.0) - 1.0;
return cheb_eval_e(&fd_2_b_cs, t, result);
}
else if(x < 10.0) {
double t = 1.0/3.0*(x-4.0) - 1.0;
return cheb_eval_e(&fd_2_c_cs, t, result);
}
else if(x < 30.0) {
double t = 0.1*x - 2.0;
gsl_sf_result c;
cheb_eval_e(&fd_2_d_cs, t, &c);
result->val = c.val * x*x*x;
result->err = c.err * x*x*x + 3.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < 1.0/GSL_ROOT3_DBL_EPSILON) {
double t = 60.0/x - 1.0;
gsl_sf_result c;
cheb_eval_e(&fd_2_e_cs, t, &c);
result->val = c.val * x*x*x;
result->err = c.err * x*x*x + 3.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < GSL_ROOT3_DBL_MAX) {
result->val = 1.0/6.0 * x*x*x;
result->err = 3.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
OVERFLOW_ERROR(result);
}
}
int gsl_sf_bessel_I1_scaled_e(const double x, gsl_sf_result * result)
{
const double xmin = 2.0 * GSL_DBL_MIN;
const double x_small = ROOT_EIGHT * GSL_SQRT_DBL_EPSILON;
const 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 < xmin) {
UNDERFLOW_ERROR(result);
}
else if(y < x_small) {
result->val = 0.5*x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(y <= 3.0) {
const double ey = exp(-y);
gsl_sf_result c;
cheb_eval_e(&bi1_cs, y*y/4.5-1.0, &c);
result->val = x * ey * (0.875 + c.val);
result->err = ey * c.err + y * GSL_DBL_EPSILON * fabs(result->val);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y <= 8.0) {
const double sy = sqrt(y);
gsl_sf_result c;
double b;
double s;
cheb_eval_e(&ai1_cs, (48.0/y-11.0)/5.0, &c);
b = (0.375 + c.val) / sy;
s = (x > 0.0 ? 1.0 : -1.0);
result->val = s * b;
result->err = c.err / sy;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
const double sy = sqrt(y);
gsl_sf_result c;
double b;
double s;
cheb_eval_e(&ai12_cs, 16.0/y-1.0, &c);
b = (0.375 + c.val) / sy;
s = (x > 0.0 ? 1.0 : -1.0);
result->val = s * b;
result->err = c.err / sy;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
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);
}
}
int gsl_sf_exp_e(const double x, gsl_sf_result * result)
{
if(x > GSL_LOG_DBL_MAX) {
OVERFLOW_ERROR(result);
}
else if(x < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else {
result->val = exp(x);
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
int
gsl_sf_dawson_e(double x, gsl_sf_result * result)
{
const double xsml = 1.225 * GSL_SQRT_DBL_EPSILON;
const double xbig = 1.0/(M_SQRT2*GSL_SQRT_DBL_EPSILON);
const double xmax = 0.1 * GSL_DBL_MAX;
const double y = fabs(x);
if(y < xsml) {
result->val = x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(y < 1.0) {
gsl_sf_result result_c;
cheb_eval_e(&daw_cs, 2.0*y*y - 1.0, &result_c);
result->val = x * (0.75 + result_c.val);
result->err = y * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y < 4.0) {
gsl_sf_result result_c;
cheb_eval_e(&daw2_cs, 0.125*y*y - 1.0, &result_c);
result->val = x * (0.25 + result_c.val);
result->err = y * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y < xbig) {
gsl_sf_result result_c;
cheb_eval_e(&dawa_cs, 32.0/(y*y) - 1.0, &result_c);
result->val = (0.5 + result_c.val) / x;
result->err = result_c.err / y;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y < xmax) {
result->val = 0.5/x;
result->err = 2.0 * GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
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);
}
}
int gsl_sf_fermi_dirac_3half_e(const double x, gsl_sf_result * result)
{
if(x < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(x < -1.0) {
/* series [Goano (6)]
*/
double ex = exp(x);
double term = ex;
double sum = term;
int n;
for(n=2; n<100 ; n++) {
double rat = (n-1.0)/n;
term *= -ex * rat * rat * sqrt(rat);
sum += term;
if(fabs(term/sum) < GSL_DBL_EPSILON) break;
}
result->val = sum;
result->err = 2.0 * fabs(sum) * GSL_DBL_EPSILON;
return GSL_SUCCESS;
}
else if(x < 1.0) {
return cheb_eval_e(&fd_3half_a_cs, x, result);
}
else if(x < 4.0) {
double t = 2.0/3.0*(x-1.0) - 1.0;
return cheb_eval_e(&fd_3half_b_cs, t, result);
}
else if(x < 10.0) {
double t = 1.0/3.0*(x-4.0) - 1.0;
return cheb_eval_e(&fd_3half_c_cs, t, result);
}
else if(x < 30.0) {
double x52 = x*x*sqrt(x);
double t = 0.1*x - 2.0;
gsl_sf_result c;
cheb_eval_e(&fd_3half_d_cs, t, &c);
result->val = c.val * x52;
result->err = c.err * x52 + 2.5 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
return fd_asymp(1.5, x, result);
}
}
int gsl_sf_exp_mult_err_e(const double x, const double dx,
const double y, const double dy,
gsl_sf_result * result)
{
const double ay = fabs(y);
if(y == 0.0) {
result->val = 0.0;
result->err = fabs(dy * exp(x));
return GSL_SUCCESS;
}
else if( ( x < 0.5*GSL_LOG_DBL_MAX && x > 0.5*GSL_LOG_DBL_MIN)
&& (ay < 0.8*GSL_SQRT_DBL_MAX && ay > 1.2*GSL_SQRT_DBL_MIN)
) {
double ex = exp(x);
result->val = y * ex;
result->err = ex * (fabs(dy) + fabs(y*dx));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
const double ly = log(ay);
const double lnr = x + ly;
if(lnr > GSL_LOG_DBL_MAX - 0.01) {
OVERFLOW_ERROR(result);
}
else if(lnr < GSL_LOG_DBL_MIN + 0.01) {
UNDERFLOW_ERROR(result);
}
else {
const double sy = GSL_SIGN(y);
const double M = floor(x);
const double N = floor(ly);
const double a = x - M;
const double b = ly - N;
const double eMN = exp(M+N);
const double eab = exp(a+b);
result->val = sy * eMN * eab;
result->err = eMN * eab * 2.0*GSL_DBL_EPSILON;
result->err += eMN * eab * fabs(dy/y);
result->err += eMN * eab * fabs(dx);
return GSL_SUCCESS;
}
}
}
int gsl_sf_bessel_j2_e(const double x, gsl_sf_result * result)
{
double ax = fabs(x);
/* CHECK_POINTER(result) */
if(x == 0.0) {
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(ax < 4.0*GSL_SQRT_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(ax < 1.3) {
const double y = x*x;
const double c1 = -1.0/14.0;
const double c2 = 1.0/504.0;
const double c3 = -1.0/33264.0;
const double c4 = 1.0/3459456.0;
const double c5 = -1.0/518918400;
const double c6 = 1.0/105859353600.0;
const double c7 = -1.0/28158588057600.0;
const double c8 = 1.0/9461285587353600.0;
const double c9 = -1.0/3916972233164390400.0;
const double sum = 1.0+y*(c1+y*(c2+y*(c3+y*(c4+y*(c5+y*(c6+y*(c7+y*(c8+y*c9))))))));
result->val = y/15.0 * sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
gsl_sf_result cos_result;
gsl_sf_result sin_result;
const int stat_cos = gsl_sf_cos_e(x, &cos_result);
const int stat_sin = gsl_sf_sin_e(x, &sin_result);
const double cos_x = cos_result.val;
const double sin_x = sin_result.val;
const double f = (3.0/(x*x) - 1.0);
result->val = (f * sin_x - 3.0*cos_x/x)/x;
result->err = fabs(f * sin_result.err/x) + fabs((3.0*cos_result.err/x)/x);
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(f*sin_x/x) + 3.0*fabs(cos_x/(x*x)));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_2(stat_cos, stat_sin);
}
}
/* [Goano (4)] */
int gsl_sf_fermi_dirac_m1_e(const double x, gsl_sf_result * result)
{
if(x < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(x < 0.0) {
const double ex = exp(x);
result->val = ex/(1.0+ex);
result->err = 2.0 * (fabs(x) + 1.0) * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
double ex = exp(-x);
result->val = 1.0/(1.0 + ex);
result->err = 2.0 * GSL_DBL_EPSILON * (x + 1.0) * ex;
return GSL_SUCCESS;
}
}
int gsl_sf_synchrotron_1_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2 * GSL_SQRT_DBL_EPSILON) {
/* BJG: added first order correction term. The taylor series
is S1(x) = ((4pi)/(sqrt(3)gamma(1/3))) * (x/2)^(1/3)
* (1 - (gamma(1/3)/2)*(x/2)^2/3 + (3/4) * (x/2)^2 ....) */
double z = pow(x, 1.0/3.0);
double cf = 1 - 8.43812762813205e-01 * z * z;
result->val = 2.14952824153447863671 * z * cf;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double c0 = M_PI/M_SQRT3;
const double px = pow(x,1.0/3.0);
const double px11 = gsl_sf_pow_int(px,11);
const double t = x*x/8.0 - 1.0;
gsl_sf_result result_c1;
gsl_sf_result result_c2;
cheb_eval_e(&synchrotron1_cs, t, &result_c1);
cheb_eval_e(&synchrotron2_cs, t, &result_c2);
result->val = px * result_c1.val - px11 * result_c2.val - c0 * x;
result->err = px * result_c1.err + px11 * result_c2.err + c0 * x * GSL_DBL_EPSILON;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < -8.0*GSL_LOG_DBL_MIN/7.0) {
const double c0 = 0.2257913526447274323630976; /* log(sqrt(pi/2)) */
const double t = (12.0 - x) / (x + 4.0);
gsl_sf_result result_c1;
cheb_eval_e(&synchrotron1a_cs, t, &result_c1);
result->val = sqrt(x) * result_c1.val * exp(c0 - x);
result->err = 2.0 * GSL_DBL_EPSILON * result->val * (fabs(c0-x)+1.0);
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_synchrotron_2_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
/* BJG: added first order correction term. The taylor series
is S2(x) = ((2pi)/(sqrt(3)*gamma(1/3))) * (x/2)^(1/3)
* (1 - (gamma(1/3)/gamma(4/3))*(x/2)^(4/3) + (gamma(1/3)/gamma(4/3))*(x/2)^2...) */
double z = pow(x, 1.0/3.0);
double cf = 1 - 1.17767156510235e+00 * z * x;
result->val = 1.07476412076723931836 * z * cf ;
result->err = 2.0 * GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double px = pow(x, 1.0/3.0);
const double px5 = gsl_sf_pow_int(px,5);
const double t = x*x/8.0 - 1.0;
gsl_sf_result cheb1;
gsl_sf_result cheb2;
cheb_eval_e(&synchrotron21_cs, t, &cheb1);
cheb_eval_e(&synchrotron22_cs, t, &cheb2);
result->val = px * cheb1.val - px5 * cheb2.val;
result->err = px * cheb1.err + px5 * cheb2.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < -8.0*GSL_LOG_DBL_MIN/7.0) {
const double c0 = 0.22579135264472743236; /* log(sqrt(pi/2)) */
const double t = (10.0 - x) / (x + 2.0);
gsl_sf_result cheb1;
cheb_eval_e(&synchrotron2a_cs, t, &cheb1);
result->val = sqrt(x) * exp(c0-x) * cheb1.val;
result->err = GSL_DBL_EPSILON * result->val * (fabs(c0-x)+1.0);
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_expint_E2_e(const double x, gsl_sf_result * result)
{
const double xmaxt = -GSL_LOG_DBL_MIN;
const double xmax = xmaxt - log(xmaxt);
/* CHECK_POINTER(result) */
if(x < -xmax) {
OVERFLOW_ERROR(result);
}
else if(x < 100.0) {
const double ex = exp(-x);
gsl_sf_result result_E1;
int stat_E1 = gsl_sf_expint_E1_e(x, &result_E1);
result->val = ex - x*result_E1.val;
result->err = fabs(x) * (GSL_DBL_EPSILON*ex + result_E1.err);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_E1;
}
else if(x < xmax) {
const double c1 = -2.0;
const double c2 = 6.0;
const double c3 = -24.0;
const double c4 = 120.0;
const double c5 = -720.0;
const double c6 = 5040.0;
const double c7 = -40320.0;
const double c8 = 362880.0;
const double c9 = -3628800.0;
const double c10 = 39916800.0;
const double c11 = -479001600.0;
const double c12 = 6227020800.0;
const double c13 = -87178291200.0;
const double y = 1.0/x;
const double sum6 = c6+y*(c7+y*(c8+y*(c9+y*(c10+y*(c11+y*(c12+y*c13))))));
const double sum = y*(c1+y*(c2+y*(c3+y*(c4+y*(c5+y*sum6)))));
result->val = exp(-x) * (1.0 + sum)/x;
result->err = 2.0 * (x + 1.0) * GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_bessel_I1_e(const double x, gsl_sf_result * result)
{
const double xmin = 2.0 * GSL_DBL_MIN;
const double x_small = ROOT_EIGHT * GSL_SQRT_DBL_EPSILON;
const 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 < xmin) {
UNDERFLOW_ERROR(result);
}
else if(y < x_small) {
result->val = 0.5*x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(y <= 3.0) {
gsl_sf_result c;
cheb_eval_e(&bi1_cs, y*y/4.5-1.0, &c);
result->val = x * (0.875 + c.val);
result->err = y * c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y < GSL_LOG_DBL_MAX) {
const double ey = exp(y);
gsl_sf_result I1_scaled;
gsl_sf_bessel_I1_scaled_e(x, &I1_scaled);
result->val = ey * I1_scaled.val;
result->err = ey * I1_scaled.err + y * GSL_DBL_EPSILON * fabs(result->val);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
OVERFLOW_ERROR(result);
}
}
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_bessel_j1_e(const double x, gsl_sf_result * result)
{
double ax = fabs(x);
/* CHECK_POINTER(result) */
if(x == 0.0) {
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(ax < 3.1*GSL_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(ax < 0.25) {
const double y = x*x;
const double c1 = -1.0/10.0;
const double c2 = 1.0/280.0;
const double c3 = -1.0/15120.0;
const double c4 = 1.0/1330560.0;
const double c5 = -1.0/172972800.0;
const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));
result->val = x/3.0 * sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
gsl_sf_result cos_result;
gsl_sf_result sin_result;
const int stat_cos = gsl_sf_cos_e(x, &cos_result);
const int stat_sin = gsl_sf_sin_e(x, &sin_result);
const double cos_x = cos_result.val;
const double sin_x = sin_result.val;
result->val = (sin_x/x - cos_x)/x;
result->err = (fabs(sin_result.err/x) + fabs(cos_result.err))/fabs(x);
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(sin_x/(x*x)) + fabs(cos_x/x));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_2(stat_cos, stat_sin);
}
}
int
gsl_sf_airy_Ai_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x < -1.0) {
gsl_sf_result a;
gsl_sf_result p;
int status_ap = airy_deriv_mod_phase(x, mode, &a, &p);
double c = cos(p.val);
result->val = a.val * c;
result->err = fabs(result->val * p.err) + fabs(c * a.err);
result->err += GSL_DBL_EPSILON * fabs(result->val);
return status_ap;
}
else if(x < 1.0) {
const double x3 = x*x*x;
gsl_sf_result result_c1;
gsl_sf_result result_c2;
cheb_eval_mode_e(&aif_cs, x3, mode, &result_c1);
cheb_eval_mode_e(&aig_cs, x3, mode, &result_c2);
result->val = (x*x*(0.125 + result_c1.val) - result_c2.val) - 0.25;
result->err = fabs(x*x*result_c1.err) + result_c2.err;
result->err += GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x*x*x < 9.0/4.0 * GSL_LOG_DBL_MIN*GSL_LOG_DBL_MIN) {
gsl_sf_result result_aps;
const double arg = -2.0*x*sqrt(x)/3.0;
const int stat_a = gsl_sf_airy_Ai_deriv_scaled_e(x, mode, &result_aps);
const int stat_e = gsl_sf_exp_mult_err_e(arg, 1.5*fabs(arg*GSL_DBL_EPSILON),
result_aps.val, result_aps.err,
result);
return GSL_ERROR_SELECT_2(stat_e, stat_a);
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_Chi_e(const double x, gsl_sf_result * result)
{
gsl_sf_result result_Ei;
gsl_sf_result result_E1;
int status_Ei = gsl_sf_expint_Ei_e(x, &result_Ei);
int status_E1 = gsl_sf_expint_E1_e(x, &result_E1);
if(status_Ei == GSL_EDOM || status_E1 == GSL_EDOM) {
DOMAIN_ERROR(result);
}
else if(status_Ei == GSL_EUNDRFLW && status_E1 == GSL_EUNDRFLW) {
UNDERFLOW_ERROR(result);
}
else if(status_Ei == GSL_EOVRFLW || status_E1 == GSL_EOVRFLW) {
OVERFLOW_ERROR(result);
}
else {
result->val = 0.5 * (result_Ei.val - result_E1.val);
result->err = 0.5 * (result_Ei.err + result_E1.err);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
int
gsl_sf_exp_err_e(const double x, const double dx, gsl_sf_result * result)
{
const double adx = fabs(dx);
/* CHECK_POINTER(result) */
if(x + adx > GSL_LOG_DBL_MAX) {
OVERFLOW_ERROR(result);
}
else if(x - adx < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else {
const double ex = exp(x);
const double edx = exp(adx);
result->val = ex;
result->err = ex * GSL_MAX_DBL(GSL_DBL_EPSILON, edx - 1.0/edx);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
int gsl_sf_synchrotron_1_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2 * GSL_SQRT_DBL_EPSILON) {
result->val = 2.14952824153447863671 * pow(x, 1.0/3.0);
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double c0 = M_PI/M_SQRT3;
const double px = pow(x,1.0/3.0);
const double px11 = gsl_sf_pow_int(px,11);
const double t = x*x/8.0 - 1.0;
gsl_sf_result result_c1;
gsl_sf_result result_c2;
cheb_eval_e(&synchrotron1_cs, t, &result_c1);
cheb_eval_e(&synchrotron2_cs, t, &result_c2);
result->val = px * result_c1.val - px11 * result_c2.val - c0 * x;
result->err = px * result_c1.err + px11 * result_c2.err + c0 * x * GSL_DBL_EPSILON;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < -8.0*GSL_LOG_DBL_MIN/7.0) {
const double c0 = 0.2257913526447274323630976; /* log(sqrt(pi/2)) */
const double t = (12.0 - x) / (x + 4.0);
gsl_sf_result result_c1;
cheb_eval_e(&synchrotron1a_cs, t, &result_c1);
result->val = sqrt(x) * result_c1.val * exp(c0 - x);
result->err = 2.0 * GSL_DBL_EPSILON * result->val * (fabs(c0-x)+1.0);
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_synchrotron_2_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
result->val = 1.07476412076723931836 * pow(x, 1.0/3.0);
result->err = 2.0 * GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double px = pow(x, 1.0/3.0);
const double px5 = gsl_sf_pow_int(px,5);
const double t = x*x/8.0 - 1.0;
gsl_sf_result cheb1;
gsl_sf_result cheb2;
cheb_eval_e(&synchrotron21_cs, t, &cheb1);
cheb_eval_e(&synchrotron22_cs, t, &cheb2);
result->val = px * cheb1.val - px5 * cheb2.val;
result->err = px * cheb1.err + px5 * cheb2.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < -8.0*GSL_LOG_DBL_MIN/7.0) {
const double c0 = 0.22579135264472743236; /* log(sqrt(pi/2)) */
const double t = (10.0 - x) / (x + 2.0);
gsl_sf_result cheb1;
cheb_eval_e(&synchrotron2a_cs, t, &cheb1);
result->val = sqrt(x) * exp(c0-x) * cheb1.val;
result->err = GSL_DBL_EPSILON * result->val * (fabs(c0-x)+1.0);
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
/* [Goano (3)] */
int gsl_sf_fermi_dirac_0_e(const double x, gsl_sf_result * result)
{
if(x < GSL_LOG_DBL_MIN) {
UNDERFLOW_ERROR(result);
}
else if(x < -5.0) {
double ex = exp(x);
double ser = 1.0 - ex*(0.5 - ex*(1.0/3.0 - ex*(1.0/4.0 - ex*(1.0/5.0 - ex/6.0))));
result->val = ex * ser;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x < 10.0) {
result->val = log(1.0 + exp(x));
result->err = fabs(x * GSL_DBL_EPSILON);
return GSL_SUCCESS;
}
else {
double ex = exp(-x);
result->val = x + ex * (1.0 - 0.5*ex + ex*ex/3.0 - ex*ex*ex/4.0);
result->err = (x + ex) * GSL_DBL_EPSILON;
return GSL_SUCCESS;
}
}
/* 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;
}
}
/* implementation for E1, allowing for scaling by exp(x) */
static
int expint_E1_impl(const double x, gsl_sf_result * result, const int scale)
{
const double xmaxt = -GSL_LOG_DBL_MIN; /* XMAXT = -LOG (R1MACH(1)) */
const double xmax = xmaxt - log(xmaxt); /* XMAX = XMAXT - LOG(XMAXT) */
/* CHECK_POINTER(result) */
if(x < -xmax && !scale) {
OVERFLOW_ERROR(result);
}
else if(x <= -10.0) {
const double s = 1.0/x * ( scale ? 1.0 : exp(-x) );
gsl_sf_result result_c;
cheb_eval_e(&AE11_cs, 20.0/x+1.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(x) + 1.0) * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= -4.0) {
const double s = 1.0/x * ( scale ? 1.0 : exp(-x) );
gsl_sf_result result_c;
cheb_eval_e(&AE12_cs, (40.0/x+7.0)/3.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= -1.0) {
const double ln_term = -log(fabs(x));
const double scale_factor = ( scale ? exp(x) : 1.0 );
gsl_sf_result result_c;
cheb_eval_e(&E11_cs, (2.0*x+5.0)/3.0, &result_c);
result->val = scale_factor * (ln_term + result_c.val);
result->err = scale_factor * (result_c.err + GSL_DBL_EPSILON * fabs(ln_term));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x == 0.0) {
DOMAIN_ERROR(result);
}
else if(x <= 1.0) {
const double ln_term = -log(fabs(x));
const double scale_factor = ( scale ? exp(x) : 1.0 );
gsl_sf_result result_c;
cheb_eval_e(&E12_cs, x, &result_c);
result->val = scale_factor * (ln_term - 0.6875 + x + result_c.val);
result->err = scale_factor * (result_c.err + GSL_DBL_EPSILON * fabs(ln_term));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double s = 1.0/x * ( scale ? 1.0 : exp(-x) );
gsl_sf_result result_c;
cheb_eval_e(&AE13_cs, (8.0/x-5.0)/3.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= xmax || scale) {
const double s = 1.0/x * ( scale ? 1.0 : exp(-x) );
gsl_sf_result result_c;
cheb_eval_e(&AE14_cs, 8.0/x-1.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * (GSL_DBL_EPSILON + result_c.err);
result->err += 2.0 * (x + 1.0) * GSL_DBL_EPSILON * fabs(result->val);
if(result->val == 0.0)
UNDERFLOW_ERROR(result);
else
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
int gsl_sf_expint_E1_e(const double x, gsl_sf_result * result)
{
const double xmaxt = -GSL_LOG_DBL_MIN; /* XMAXT = -LOG (R1MACH(1)) */
const double xmax = xmaxt - log(xmaxt); /* XMAX = XMAXT - LOG(XMAXT) */
/* CHECK_POINTER(result) */
if(x < -xmax) {
OVERFLOW_ERROR(result);
}
else if(x <= -10.0) {
const double s = exp(-x)/x;
gsl_sf_result result_c;
cheb_eval_e(&AE11_cs, 20.0/x+1.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * (fabs(x) + 1.0) * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= -4.0) {
const double s = exp(-x)/x;
gsl_sf_result result_c;
cheb_eval_e(&AE12_cs, (40.0/x+7.0)/3.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= -1.0) {
const double ln_term = -log(fabs(x));
gsl_sf_result result_c;
cheb_eval_e(&E11_cs, (2.0*x+5.0)/3.0, &result_c);
result->val = ln_term + result_c.val;
result->err = result_c.err + GSL_DBL_EPSILON * fabs(ln_term);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x == 0.0) {
DOMAIN_ERROR(result);
}
else if(x <= 1.0) {
const double ln_term = -log(fabs(x));
gsl_sf_result result_c;
cheb_eval_e(&E12_cs, x, &result_c);
result->val = ln_term - 0.6875 + x + result_c.val;
result->err = result_c.err + GSL_DBL_EPSILON * fabs(ln_term);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double s = exp(-x)/x;
gsl_sf_result result_c;
cheb_eval_e(&AE13_cs, (8.0/x-5.0)/3.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x <= xmax) {
const double s = exp(-x)/x;
gsl_sf_result result_c;
cheb_eval_e(&AE14_cs, 8.0/x-1.0, &result_c);
result->val = s * (1.0 + result_c.val);
result->err = s * (GSL_DBL_EPSILON + result_c.err);
result->err += 2.0 * (x + 1.0) * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
UNDERFLOW_ERROR(result);
}
}
