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);
}
}
double gsl_sf_bessel_J0(const double x)
{
EVAL_RESULT(gsl_sf_bessel_J0_e(x, &result));
}
int
gsl_sf_legendre_Pl_e(const int l, const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(l < 0 || x < -1.0 || x > 1.0) {
DOMAIN_ERROR(result);
}
else if(l == 0) {
result->val = 1.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(l == 1) {
result->val = x;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(l == 2) {
result->val = 0.5 * (3.0*x*x - 1.0);
result->err = 3.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_SUCCESS;
}
else if(x == 1.0) {
result->val = 1.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(x == -1.0) {
result->val = ( GSL_IS_ODD(l) ? -1.0 : 1.0 );
result->err = 0.0;
return GSL_SUCCESS;
}
else if(l < 100000) {
/* Compute by upward recurrence on l.
*/
double p_mm = 1.0; /* P_0(x) */
double p_mmp1 = x; /* P_1(x) */
double p_ell = p_mmp1;
int ell;
for(ell=2; ell <= l; ell++){
p_ell = (x*(2*ell-1)*p_mmp1 - (ell-1)*p_mm) / ell;
p_mm = p_mmp1;
p_mmp1 = p_ell;
}
result->val = p_ell;
result->err = (0.5 * ell + 1.0) * GSL_DBL_EPSILON * fabs(p_ell);
return GSL_SUCCESS;
}
else {
/* Asymptotic expansion.
* [Olver, p. 473]
*/
double u = l + 0.5;
double th = acos(x);
gsl_sf_result J0;
gsl_sf_result Jm1;
int stat_J0 = gsl_sf_bessel_J0_e(u*th, &J0);
int stat_Jm1 = gsl_sf_bessel_Jn_e(-1, u*th, &Jm1);
double pre;
double B00;
double c1;
/* B00 = 1/8 (1 - th cot(th) / th^2
* pre = sqrt(th/sin(th))
*/
if(th < GSL_ROOT4_DBL_EPSILON) {
B00 = (1.0 + th*th/15.0)/24.0;
pre = 1.0 + th*th/12.0;
}
else {
double sin_th = sqrt(1.0 - x*x);
double cot_th = x / sin_th;
B00 = 1.0/8.0 * (1.0 - th * cot_th) / (th*th);
pre = sqrt(th/sin_th);
}
c1 = th/u * B00;
result->val = pre * (J0.val + c1 * Jm1.val);
result->err = pre * (J0.err + fabs(c1) * Jm1.err);
result->err += GSL_SQRT_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_2(stat_J0, stat_Jm1);
}
}
int gsl_sf_bessel_Jn_e(int n, double x, gsl_sf_result * result)
{
int sign = 1;
if(n < 0) {
/* reduce to case n >= 0 */
n = -n;
if(GSL_IS_ODD(n)) sign = -sign;
}
if(x < 0.0) {
/* reduce to case x >= 0. */
x = -x;
if(GSL_IS_ODD(n)) sign = -sign;
}
/* CHECK_POINTER(result) */
if(n == 0) {
gsl_sf_result b0;
int stat_J0 = gsl_sf_bessel_J0_e(x, &b0);
result->val = sign * b0.val;
result->err = b0.err;
return stat_J0;
}
else if(n == 1) {
gsl_sf_result b1;
int stat_J1 = gsl_sf_bessel_J1_e(x, &b1);
result->val = sign * b1.val;
result->err = b1.err;
return stat_J1;
}
else {
if(x == 0.0) {
result->val = 0.0;
result->err = 0.0;
return GSL_SUCCESS;
}
else if(x*x < 10.0*(n+1.0)*GSL_ROOT5_DBL_EPSILON) {
gsl_sf_result b;
int status = gsl_sf_bessel_IJ_taylor_e((double)n, x, -1, 50, GSL_DBL_EPSILON, &b);
result->val = sign * b.val;
result->err = b.err;
result->err += GSL_DBL_EPSILON * fabs(result->val);
return status;
}
else if(GSL_ROOT3_DBL_EPSILON * x > (n*n+1.0)) {
int status = gsl_sf_bessel_Jnu_asympx_e((double)n, x, result);
result->val *= sign;
return status;
}
else if(n > 50) {
int status = gsl_sf_bessel_Jnu_asymp_Olver_e((double)n, x, result);
result->val *= sign;
return status;
}
else {
double ans;
double err;
double ratio;
double sgn;
int stat_b;
int stat_CF1 = gsl_sf_bessel_J_CF1((double)n, x, &ratio, &sgn);
/* backward recurrence */
double Jkp1 = GSL_SQRT_DBL_MIN * ratio;
double Jk = GSL_SQRT_DBL_MIN;
double Jkm1;
int k;
for(k=n; k>0; k--) {
Jkm1 = 2.0*k/x * Jk - Jkp1;
Jkp1 = Jk;
Jk = Jkm1;
}
if(fabs(Jkp1) > fabs(Jk)) {
gsl_sf_result b1;
stat_b = gsl_sf_bessel_J1_e(x, &b1);
ans = b1.val/Jkp1 * GSL_SQRT_DBL_MIN;
err = b1.err/Jkp1 * GSL_SQRT_DBL_MIN;
}
else {
gsl_sf_result b0;
stat_b = gsl_sf_bessel_J0_e(x, &b0);
ans = b0.val/Jk * GSL_SQRT_DBL_MIN;
err = b0.err/Jk * GSL_SQRT_DBL_MIN;
}
result->val = sign * ans;
result->err = fabs(err);
return GSL_ERROR_SELECT_2(stat_CF1, stat_b);
}
}
}
