void eta_int(int *n, int *len, double *val, double *err, int *status)
{
int i;
gsl_sf_result result;
gsl_set_error_handler_off();
for(i = 0; i< *len ; i++){
status[i] = gsl_sf_eta_int_e(n[i], &result) ;
val[i] = result.val;
err[i] = result.err;
}
}
/* 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_fermi_dirac_int_e(const int j, const double x, gsl_sf_result * result)
{
if(j < -1) {
return fd_nint(j, x, result);
}
else if (j == -1) {
return gsl_sf_fermi_dirac_m1_e(x, result);
}
else if(j == 0) {
return gsl_sf_fermi_dirac_0_e(x, result);
}
else if(j == 1) {
return gsl_sf_fermi_dirac_1_e(x, result);
}
else if(j == 2) {
return gsl_sf_fermi_dirac_2_e(x, result);
}
else if(x < 0.0) {
return fd_neg(j, x, result);
}
else if(x == 0.0) {
return gsl_sf_eta_int_e(j+1, result);
}
else if(x < 1.5) {
return fd_series_int(j, x, result);
}
else {
gsl_sf_result fasymp;
int stat_asymp = fd_asymp(j, x, &fasymp);
if(stat_asymp == GSL_SUCCESS) {
result->val = fasymp.val;
result->err = fasymp.err;
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return stat_asymp;
}
else {
return fd_UMseries_int(j, x, result);
}
}
}
/* Series evaluation for small x > 0, integer j > 0; x < Pi.
* [Goano (8)]
*/
static
int
fd_series_int(const int j, const double x, gsl_sf_result * result)
{
int n;
double sum = 0.0;
double del;
double pow_factor = 1.0;
gsl_sf_result eta_factor;
gsl_sf_eta_int_e(j + 1, &eta_factor);
del = pow_factor * eta_factor.val;
sum += del;
/* Sum terms where the argument
* of eta() is positive.
*/
for(n=1; n<=j+2; n++) {
gsl_sf_eta_int_e(j+1-n, &eta_factor);
pow_factor *= x/n;
del = pow_factor * eta_factor.val;
sum += del;
if(fabs(del/sum) < GSL_DBL_EPSILON) break;
}
/* Now sum the terms where eta() is negative.
* The argument of eta() must be odd as well,
* so it is convenient to transform the series
* as follows:
*
* Sum[ eta(j+1-n) x^n / n!, {n,j+4,Infinity}]
* = x^j / j! Sum[ eta(1-2m) x^(2m) j! / (2m+j)! , {m,2,Infinity}]
*
* We do not need to do this sum if j is large enough.
*/
if(j < 32) {
int m;
gsl_sf_result jfact;
double sum2;
double pre2;
gsl_sf_fact_e((unsigned int)j, &jfact);
pre2 = gsl_sf_pow_int(x, j) / jfact.val;
gsl_sf_eta_int_e(-3, &eta_factor);
pow_factor = x*x*x*x / ((j+4)*(j+3)*(j+2)*(j+1));
sum2 = eta_factor.val * pow_factor;
for(m=3; m<24; m++) {
gsl_sf_eta_int_e(1-2*m, &eta_factor);
pow_factor *= x*x / ((j+2*m)*(j+2*m-1));
sum2 += eta_factor.val * pow_factor;
}
sum += pre2 * sum2;
}
result->val = sum;
result->err = 2.0 * GSL_DBL_EPSILON * fabs(sum);
return GSL_SUCCESS;
}
double gsl_sf_eta_int(const int s)
{
EVAL_RESULT(gsl_sf_eta_int_e(s, &result));
}
