static double olver_A3(double z, double abs_zeta)
{
if(z < 0.9) {
const double x = 20.0*z/9.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&A3_lt1_cs, x, &c);
return c.val;
}
else if(z < 1.1) {
double a = 1.0-z;
const double c0 = -0.000354211971457743840771125759200;
const double c1 = -0.000312322527890318832782774881353;
const double c2 = 0.000277947465383133980329617631915;
const double c3 = 0.000919803044747966977054155192400;
const double c4 = 0.001147600388275977640983696906320;
const double c5 = 0.000869239326123625742931772044544;
const double c6 = 0.000287392257282507334785281718027;
return c0 + a*(c1 + a*(c2 + a*(c3 + a*(c4 + a*(c5 + a*c6)))));
}
else {
const double x = 11.0/(5.0*z) - 1.0;
const double zi2 = 1.0/(z*z);
gsl_sf_result c;
cheb_eval_e(&A3_gt1_cs, x, &c);
return c.val * zi2*zi2*zi2;
}
}
static double olver_B2(double z, double abs_zeta)
{
if(z < 0.8) {
const double x = 5.0*z/2.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&B2_lt1_cs, x, &c);
return c.val / z;
}
else if(z <= 1.2) {
const double a = 1.0-z;
const double c0 = 0.00055221307672129279005986982501;
const double c1 = 0.00089586516310476929281129228969;
const double c2 = 0.00067015003441569770883539158863;
const double c3 = 0.00010166263361949045682945811828;
const double c4 = -0.00044086345133806887291336488582;
const double c5 = -0.00073963081508788743392883072523;
const double c6 = -0.00076745494377839561259903887331;
const double c7 = -0.00060829038106040362291568012663;
const double c8 = -0.00037128707528893496121336168683;
const double c9 = -0.00014116325105702609866850307176;
return c0+a*(c1+a*(c2+a*(c3+a*(c4+a*(c5+a*(c6+a*(c7+a*(c8+a*c9))))))));
}
else {
const double zi = 1.0/z;
const double x = 12.0/5.0 * zi - 1.0;
gsl_sf_result c;
cheb_eval_e(&B2_gt1_cs, x, &c);
return c.val * zi*zi*zi;
}
}
static double olver_B3(double z, double abs_zeta)
{
if(z < 0.8) {
const double x = 5.0*z/2.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&B3_lt1_cs, x, &c);
return c.val;
}
else if(z < 1.2) {
const double a = 1.0-z;
const double c0 = -0.00047461779655995980754441833105;
const double c1 = -0.00095572913429464297452176811898;
const double c2 = -0.00080369634512082892655558133973;
const double c3 = -0.00000727921669154784138080600339;
const double c4 = 0.00093162500331581345235746518994;
const double c5 = 0.00149848796913751497227188612403;
const double c6 = 0.00148406039675949727870390426462;
return c0 + a*(c1 + a*(c2 + a*(c3 + a*(c4 + a*(c5 + a*c6)))));
}
else {
const double x = 12.0/(5.0*z) - 1.0;
const double zi2 = 1.0/(z*z);
gsl_sf_result c;
cheb_eval_e(&B3_gt1_cs, x, &c);
return c.val * zi2*zi2*zi2;
}
}
/* assumes s >= 0 and s != 1.0 */
inline
static int
riemann_zeta_sgt0(double s, gsl_sf_result * result)
{
if(s < 1.0) {
gsl_sf_result c;
cheb_eval_e(&zeta_xlt1_cs, 2.0*s - 1.0, &c);
result->val = c.val / (s - 1.0);
result->err = c.err / fabs(s-1.0) + GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(s <= 20.0) {
double x = (2.0*s - 21.0)/19.0;
gsl_sf_result c;
cheb_eval_e(&zeta_xgt1_cs, x, &c);
result->val = c.val / (s - 1.0);
result->err = c.err / (s - 1.0) + GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
double f2 = 1.0 - pow(2.0,-s);
double f3 = 1.0 - pow(3.0,-s);
double f5 = 1.0 - pow(5.0,-s);
double f7 = 1.0 - pow(7.0,-s);
result->val = 1.0/(f2*f3*f5*f7);
result->err = 3.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
static double olver_A4(double z, double abs_zeta)
{
if(z < 0.8) {
const double x = 5.0*z/2.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&A4_lt1_cs, x, &c);
return c.val;
}
else if(z < 1.2) {
double a = 1.0-z;
const double c0 = 0.00037819419920177291402661228437;
const double c1 = 0.00040494390552363233477213857527;
const double c2 = -0.00045764735528936113047289344569;
const double c3 = -0.00165361044229650225813161341879;
const double c4 = -0.00217527517983360049717137015539;
const double c5 = -0.00152003287866490735107772795537;
return c0 + a*(c1 + a*(c2 + a*(c3 + a*(c4 + a*c5))));
}
else {
const double x = 12.0/(5.0*z) - 1.0;
const double zi2 = 1.0/(z*z);
gsl_sf_result c;
cheb_eval_e(&A4_gt1_cs, x, &c);
return c.val * zi2*zi2*zi2*zi2;
}
}
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_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);
}
}
static
int
gsl_sf_temme_gamma(const double nu, double * g_1pnu, double * g_1mnu, double * g1, double * g2)
{
const double anu = fabs(nu); /* functions are even */
const double x = 4.0*anu - 1.0;
gsl_sf_result r_g1;
gsl_sf_result r_g2;
cheb_eval_e(&g1_cs, x, &r_g1);
cheb_eval_e(&g2_cs, x, &r_g2);
*g1 = r_g1.val;
*g2 = r_g2.val;
*g_1mnu = 1.0/(r_g2.val + nu * r_g1.val);
*g_1pnu = 1.0/(r_g2.val - nu * r_g1.val);
return GSL_SUCCESS;
}
int gsl_sf_Ci_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x <= 0.0) {
DOMAIN_ERROR(result);
}
else if(x <= 4.0) {
const double lx = log(x);
const double y = (x*x-8.0)*0.125;
gsl_sf_result result_c;
cheb_eval_e(&ci_cs, y, &result_c);
result->val = lx - 0.5 + result_c.val;
result->err = 2.0 * GSL_DBL_EPSILON * (fabs(lx) + 0.5) + result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
gsl_sf_result sin_result;
gsl_sf_result cos_result;
int stat_sin = gsl_sf_sin_e(x, &sin_result);
int stat_cos = gsl_sf_cos_e(x, &cos_result);
gsl_sf_result f;
gsl_sf_result g;
fg_asymp(x, &f, &g);
result->val = f.val*sin_result.val - g.val*cos_result.val;
result->err = fabs(f.err*sin_result.val);
result->err += fabs(g.err*cos_result.val);
result->err += fabs(f.val*sin_result.err);
result->err += fabs(g.val*cos_result.err);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_2(stat_sin, stat_cos);
}
}
int gsl_sf_sinc_e(double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
{
const double ax = fabs(x);
if(ax < 0.8) {
/* Do not go to the limit of the fit since
* there is a zero there and the Chebyshev
* accuracy will go to zero.
*/
return cheb_eval_e(&sinc_cs, 2.0*ax-1.0, result);
}
else if(ax < 100.0) {
/* Small arguments are no problem.
* We trust the library sin() to
* roughly machine precision.
*/
result->val = sin(M_PI * ax)/(M_PI * ax);
result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
/* Large arguments must be handled separately.
*/
const double r = M_PI*ax;
gsl_sf_result s;
int stat_s = gsl_sf_sin_e(r, &s);
result->val = s.val/r;
result->err = s.err/r + 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_s;
}
}
}
int gsl_sf_bessel_K1_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x <= 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*GSL_DBL_MIN) {
OVERFLOW_ERROR(result);
}
else if(x <= 2.0) {
const double lx = log(x);
int stat_I1;
gsl_sf_result I1;
gsl_sf_result c;
cheb_eval_e(&bk1_cs, 0.5*x*x-1.0, &c);
stat_I1 = gsl_sf_bessel_I1_e(x, &I1);
result->val = (lx-M_LN2)*I1.val + (0.75 + c.val)/x;
result->err = c.err/x + fabs(lx)*I1.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_I1;
}
else {
gsl_sf_result K1_scaled;
int stat_K1 = gsl_sf_bessel_K1_scaled_e(x, &K1_scaled);
int stat_e = gsl_sf_exp_mult_err_e(-x, 0.0,
K1_scaled.val, K1_scaled.err,
result);
result->err = fabs(result->val) * (GSL_DBL_EPSILON*fabs(x) + K1_scaled.err/K1_scaled.val);
return GSL_ERROR_SELECT_2(stat_e, stat_K1);
}
}
int gsl_sf_bessel_K0_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x <= 0.0) {
DOMAIN_ERROR(result);
}
else if(x <= 2.0) {
const double lx = log(x);
int stat_I0;
gsl_sf_result I0;
gsl_sf_result c;
cheb_eval_e(&bk0_cs, 0.5*x*x-1.0, &c);
stat_I0 = gsl_sf_bessel_I0_e(x, &I0);
result->val = (-lx+M_LN2)*I0.val - 0.25 + c.val;
result->err = (fabs(lx) + M_LN2) * I0.err + c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_I0;
}
else {
gsl_sf_result K0_scaled;
int stat_K0 = gsl_sf_bessel_K0_scaled_e(x, &K0_scaled);
int stat_e = gsl_sf_exp_mult_err_e(-x, GSL_DBL_EPSILON*fabs(x),
K0_scaled.val, K0_scaled.err,
result);
return GSL_ERROR_SELECT_2(stat_e, stat_K0);
}
}
int gsl_sf_Si_e(const double x, gsl_sf_result * result)
{
double ax = fabs(x);
/* CHECK_POINTER(result) */
if(ax < GSL_SQRT_DBL_EPSILON) {
result->val = x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(ax <= 4.0) {
gsl_sf_result result_c;
cheb_eval_e(&si_cs, (x*x-8.0)*0.125, &result_c);
result->val = x * (0.75 + result_c.val);
result->err = ax * result_c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
/* Note there is no loss of precision
* here bcause of the leading constant.
*/
gsl_sf_result f;
gsl_sf_result g;
fg_asymp(ax, &f, &g);
result->val = 0.5 * M_PI - f.val*cos(ax) - g.val*sin(ax);
result->err = f.err + g.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
if(x < 0.0) result->val = -result->val;
return GSL_SUCCESS;
}
}
int gsl_sf_bessel_I0_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 = 0.5*y*y;
return GSL_SUCCESS;
}
else if(y <= 3.0) {
gsl_sf_result c;
cheb_eval_e(&bi0_cs, y*y/4.5-1.0, &c);
result->val = 2.75 + c.val;
result->err = GSL_DBL_EPSILON * (2.75 + fabs(c.val));
result->err += c.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(y < GSL_LOG_DBL_MAX - 1.0) {
const double ey = exp(y);
gsl_sf_result b_scaled;
gsl_sf_bessel_I0_scaled_e(x, &b_scaled);
result->val = ey * b_scaled.val;
result->err = ey * b_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_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_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_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_erfc_e(double x, gsl_sf_result * result)
{
const double ax = fabs(x);
double e_val, e_err;
/* CHECK_POINTER(result) */
if (ax <= 1.0) {
double t = 2.0 * ax - 1.0;
gsl_sf_result c;
cheb_eval_e(&erfc_xlt1_cs, t, &c);
e_val = c.val;
e_err = c.err;
} else if (ax <= 5.0) {
double ex2 = exp(-x * x);
double t = 0.5 * (ax - 3.0);
gsl_sf_result c;
cheb_eval_e(&erfc_x15_cs, t, &c);
e_val = ex2 * c.val;
e_err = ex2 * (c.err + 2.0 * fabs(x) * GSL_DBL_EPSILON);
} else if (ax < 10.0) {
double exterm = exp(-x * x) / ax;
double t = (2.0 * ax - 15.0) / 5.0;
gsl_sf_result c;
cheb_eval_e(&erfc_x510_cs, t, &c);
e_val = exterm * c.val;
e_err =
exterm * (c.err + 2.0 * fabs(x) * GSL_DBL_EPSILON +
GSL_DBL_EPSILON);
} else {
e_val = erfc8(ax);
e_err = (x * x + 1.0) * GSL_DBL_EPSILON * fabs(e_val);
}
if (x < 0.0) {
result->val = 2.0 - e_val;
result->err = e_err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
} else {
result->val = e_val;
result->err = e_err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
}
return GSL_SUCCESS;
}
int gsl_sf_debye_6_e(const double x, gsl_sf_result * result)
{
const double val_infinity = 4356.06887828990661194792541535 ;
const double xcut = -GSL_LOG_DBL_MIN;
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
result->val = 1.0 - 3.0*x/7.0 + x*x/16.0;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double t = x*x/8.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&adeb6_cs, t, &c);
result->val = c.val - 3.0*x/7.0;
result->err = c.err + GSL_DBL_EPSILON * 3.0*x/7.0;
return GSL_SUCCESS;
}
else if(x < -(M_LN2 + GSL_LOG_DBL_EPSILON)) {
const int nexp = floor(xcut/x);
const double ex = exp(-x);
double xk = nexp * x;
double rk = nexp;
double sum = 0.0;
int i;
for(i=nexp; i>=1; i--) {
double xk_inv = 1.0/xk;
sum *= ex;
sum += ((((((720.0*xk_inv + 720.0)*xk_inv + 360.0)*xk_inv + 120.0)*xk_inv + 30.0)*xk_inv+ 6.0)*xk_inv+ 1.0) / rk;
rk -= 1.0;
xk -= x;
}
result->val = val_infinity/(x*x*x*x*x*x) - 6.0 * sum * ex;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x < xcut) {
const double x2 = x*x;
const double x4 = x2*x2;
const double x6 = x4*x2;
const double sum = 720.0 + 720.0*x + 360.0*x2 + 120.0*x2*x + 30.0*x4 + 6.0*x4*x +x6 ;
result->val = (val_infinity - 6.0 * sum * exp(-x)) / x6;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
result->val = (((((val_infinity/x)/x)/x)/x)/x)/x ;
result->err = GSL_DBL_EPSILON * result->val;
CHECK_UNDERFLOW(result);
return GSL_SUCCESS;
}
}
int gsl_sf_debye_5_e(const double x, gsl_sf_result * result)
{
const double val_infinity = 610.405837190669483828710757875 ;
const double xcut = -GSL_LOG_DBL_MIN;
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
result->val = 1.0 - 5.0*x/12.0 + 5.0*x*x/84.0;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double t = x*x/8.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&adeb5_cs, t, &c);
result->val = c.val - 5.0*x/12.0;
result->err = c.err + GSL_DBL_EPSILON * 5.0*x/12.0;
return GSL_SUCCESS;
}
else if(x < -(M_LN2 + GSL_LOG_DBL_EPSILON)) {
const int nexp = floor(xcut/x);
const double ex = exp(-x);
double xk = nexp * x;
double rk = nexp;
double sum = 0.0;
int i;
for(i=nexp; i>=1; i--) {
double xk_inv = 1.0/xk;
sum *= ex;
sum += (((((120.0*xk_inv + 120.0)*xk_inv + 60.0)*xk_inv + 20.0)*xk_inv + 5.0)*xk_inv+ 1.0) / rk;
rk -= 1.0;
xk -= x;
}
result->val = val_infinity/(x*x*x*x*x) - 5.0 * sum * ex;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x < xcut) {
const double x2 = x*x;
const double x4 = x2*x2;
const double x5 = x4*x;
const double sum = 120.0 + 120.0*x + 60.0*x2 + 20.0*x2*x + 5.0*x4 + x5;
result->val = (val_infinity - 5.0 * sum * exp(-x)) / x5;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
result->val = ((((val_infinity/x)/x)/x)/x)/x;
result->err = GSL_DBL_EPSILON * result->val;
CHECK_UNDERFLOW(result);
return GSL_SUCCESS;
}
}
/* x >= 4.0 */
static void fg_asymp(const double x, gsl_sf_result * f, gsl_sf_result * g)
{
/*
xbig = sqrt (1.0/r1mach(3))
xmaxf = exp (amin1(-alog(r1mach(1)), alog(r1mach(2))) - 0.01)
xmaxg = 1.0/sqrt(r1mach(1))
xbnd = sqrt(50.0)
*/
const double xbig = 1.0/GSL_SQRT_DBL_EPSILON;
const double xmaxf = 1.0/GSL_DBL_MIN;
const double xmaxg = 1.0/GSL_SQRT_DBL_MIN;
const double xbnd = 7.07106781187;
const double x2 = x*x;
if(x <= xbnd) {
gsl_sf_result result_c1;
gsl_sf_result result_c2;
cheb_eval_e(&f1_cs, (1.0/x2-0.04125)/0.02125, &result_c1);
cheb_eval_e(&g1_cs, (1.0/x2-0.04125)/0.02125, &result_c2);
f->val = (1.0 + result_c1.val)/x;
g->val = (1.0 + result_c2.val)/x2;
f->err = result_c1.err/x + 2.0 * GSL_DBL_EPSILON * fabs(f->val);
g->err = result_c2.err/x2 + 2.0 * GSL_DBL_EPSILON * fabs(g->val);
}
else if(x <= xbig) {
gsl_sf_result result_c1;
gsl_sf_result result_c2;
cheb_eval_e(&f2_cs, 100.0/x2-1.0, &result_c1);
cheb_eval_e(&g2_cs, 100.0/x2-1.0, &result_c2);
f->val = (1.0 + result_c1.val)/x;
g->val = (1.0 + result_c2.val)/x2;
f->err = result_c1.err/x + 2.0 * GSL_DBL_EPSILON * fabs(f->val);
g->err = result_c2.err/x2 + 2.0 * GSL_DBL_EPSILON * fabs(g->val);
}
else {
f->val = (x < xmaxf ? 1.0/x : 0.0);
g->val = (x < xmaxg ? 1.0/x2 : 0.0);
f->err = 2.0 * GSL_DBL_EPSILON * fabs(f->val);
g->err = 2.0 * GSL_DBL_EPSILON * fabs(g->val);
}
return;
}
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_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_debye_4_e(const double x, gsl_sf_result * result)
{
const double val_infinity = 99.5450644937635129;
const double xcut = -GSL_LOG_DBL_MIN;
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
result->val = 1.0 - 2.0*x/5.0 + x*x/18.0;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double t = x*x/8.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&adeb4_cs, t, &c);
result->val = c.val - 2.0*x/5.0;
result->err = c.err + GSL_DBL_EPSILON * 2.0*x/5.0;
return GSL_SUCCESS;
}
else if(x < -(M_LN2 + GSL_LOG_DBL_EPSILON)) {
const int nexp = floor(xcut/x);
const double ex = exp(-x);
double xk = nexp * x;
double rk = nexp;
double sum = 0.0;
int i;
for(i=nexp; i>=1; i--) {
double xk_inv = 1.0/xk;
sum *= ex;
sum += ((((24.0*xk_inv + 24.0)*xk_inv + 12.0)*xk_inv + 4.0)*xk_inv + 1.0) / rk;
rk -= 1.0;
xk -= x;
}
result->val = val_infinity/(x*x*x*x) - 4.0 * sum * ex;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x < xcut) {
const double x2 = x*x;
const double x4 = x2*x2;
const double sum = 24.0 + 24.0*x + 12.0*x2 + 4.0*x2*x + x4;
result->val = (val_infinity - 4.0 * sum * exp(-x)) / x4;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
result->val = (((val_infinity/x)/x)/x)/x;
result->err = GSL_DBL_EPSILON * result->val;
CHECK_UNDERFLOW(result);
return GSL_SUCCESS;
}
}
/* works for 5 < s < 15*/
static int
riemann_zeta_minus_1_intermediate_s(double s, gsl_sf_result * result)
{
double t = (s - 10.0)/5.0;
gsl_sf_result c;
cheb_eval_e(&zetam1_inter_cs, t, &c);
result->val = exp(c.val) + pow(2.0, -s);
result->err = (c.err + 2.0*GSL_DBL_EPSILON)*result->val;
return GSL_SUCCESS;
}
int gsl_sf_debye_3_e(const double x, gsl_sf_result * result)
{
const double val_infinity = 19.4818182068004875;
const double xcut = -GSL_LOG_DBL_MIN;
/* CHECK_POINTER(result) */
if(x < 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*M_SQRT2*GSL_SQRT_DBL_EPSILON) {
result->val = 1.0 - 3.0*x/8.0 + x*x/20.0;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x <= 4.0) {
const double t = x*x/8.0 - 1.0;
gsl_sf_result c;
cheb_eval_e(&adeb3_cs, t, &c);
result->val = c.val - 0.375*x;
result->err = c.err + GSL_DBL_EPSILON * 0.375*x;
return GSL_SUCCESS;
}
else if(x < -(M_LN2 + GSL_LOG_DBL_EPSILON)) {
const int nexp = floor(xcut/x);
const double ex = exp(-x);
double xk = nexp * x;
double rk = nexp;
double sum = 0.0;
int i;
for(i=nexp; i>=1; i--) {
double xk_inv = 1.0/xk;
sum *= ex;
sum += (((6.0*xk_inv + 6.0)*xk_inv + 3.0)*xk_inv + 1.0) / rk;
rk -= 1.0;
xk -= x;
}
result->val = val_infinity/(x*x*x) - 3.0 * sum * ex;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else if(x < xcut) {
const double x3 = x*x*x;
const double sum = 6.0 + 6.0*x + 3.0*x*x + x3;
result->val = (val_infinity - 3.0 * sum * exp(-x)) / x3;
result->err = GSL_DBL_EPSILON * result->val;
return GSL_SUCCESS;
}
else {
result->val = ((val_infinity/x)/x)/x;
result->err = GSL_DBL_EPSILON * result->val;
CHECK_UNDERFLOW(result);
return GSL_SUCCESS;
}
}
int
gsl_sf_atanint_e(const double x, gsl_sf_result * result)
{
const double ax = fabs(x);
const double sgn = GSL_SIGN(x);
/* CHECK_POINTER(result) */
if(ax == 0.0) {
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(ax < 0.5*GSL_SQRT_DBL_EPSILON) {
result->val = x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(ax <= 1.0) {
const double t = 2.0 * (x*x - 0.5);
gsl_sf_result result_c;
cheb_eval_e(&atanint_cs, t, &result_c);
result->val = x * result_c.val;
result->err = x * result_c.err;
result->err += GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(ax < 1.0/GSL_SQRT_DBL_EPSILON) {
const double t = 2.0 * (1.0/(x*x) - 0.5);
gsl_sf_result result_c;
cheb_eval_e(&atanint_cs, t, &result_c);
result->val = sgn * (0.5*M_PI*log(ax) + result_c.val/ax);
result->err = result_c.err/ax + fabs(result->val*GSL_DBL_EPSILON);
result->err += GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
result->val = sgn * 0.5*M_PI*log(ax);
result->err = 2.0 * fabs(result->val * GSL_DBL_EPSILON);
return GSL_SUCCESS;
}
}
int gsl_sf_bessel_K1_scaled_e(const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(x <= 0.0) {
DOMAIN_ERROR(result);
}
else if(x < 2.0*GSL_DBL_MIN) {
OVERFLOW_ERROR(result);
}
else if(x <= 2.0) {
const double lx = log(x);
const double ex = exp(x);
int stat_I1;
gsl_sf_result I1;
gsl_sf_result c;
cheb_eval_e(&bk1_cs, 0.5*x*x-1.0, &c);
stat_I1 = gsl_sf_bessel_I1_e(x, &I1);
result->val = ex * ((lx-M_LN2)*I1.val + (0.75 + c.val)/x);
result->err = ex * (c.err/x + fabs(lx)*I1.err);
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_I1;
}
else if(x <= 8.0) {
const double sx = sqrt(x);
gsl_sf_result c;
cheb_eval_e(&ak1_cs, (16.0/x-5.0)/3.0, &c);
result->val = (1.25 + c.val) / sx;
result->err = c.err / sx;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else {
const double sx = sqrt(x);
gsl_sf_result c;
cheb_eval_e(&ak12_cs, 16.0/x-1.0, &c);
result->val = (1.25 + c.val) / sx;
result->err = c.err / sx;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
}
