int gsl_sf_bessel_yl_e(int l, const double x, gsl_sf_result * result)
{
/* CHECK_POINTER(result) */
if(l < 0 || x <= 0.0) {
DOMAIN_ERROR(result);
}
else if(l == 0) {
return gsl_sf_bessel_y0_e(x, result);
}
else if(l == 1) {
return gsl_sf_bessel_y1_e(x, result);
}
else if(l == 2) {
return gsl_sf_bessel_y2_e(x, result);
}
else if(x < 3.0) {
return bessel_yl_small_x(l, x, result);
}
else if(GSL_ROOT3_DBL_EPSILON * x > (l*l + l + 1.0)) {
int status = gsl_sf_bessel_Ynu_asympx_e(l + 0.5, x, result);
double pre = sqrt((0.5*M_PI)/x);
result->val *= pre;
result->err *= pre;
return status;
}
else if(l > 40) {
int status = gsl_sf_bessel_Ynu_asymp_Olver_e(l + 0.5, x, result);
double pre = sqrt((0.5*M_PI)/x);
result->val *= pre;
result->err *= pre;
return status;
}
else {
/* recurse upward */
gsl_sf_result r_by;
gsl_sf_result r_bym;
int stat_1 = gsl_sf_bessel_y1_e(x, &r_by);
int stat_0 = gsl_sf_bessel_y0_e(x, &r_bym);
double bym = r_bym.val;
double by = r_by.val;
double byp;
int j;
for(j=1; j<l; j++) {
byp = (2*j+1)/x*by - bym;
bym = by;
by = byp;
}
result->val = by;
result->err = fabs(result->val) * (GSL_DBL_EPSILON + fabs(r_by.err/r_by.val) + fabs(r_bym.err/r_bym.val));
return GSL_ERROR_SELECT_2(stat_1, stat_0);
}
}
int
gsl_sf_bessel_Yn_e(int n, const 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 = -1;
}
/* CHECK_POINTER(result) */
if(n == 0) {
int status = gsl_sf_bessel_Y0_e(x, result);
result->val *= sign;
return status;
}
else if(n == 1) {
int status = gsl_sf_bessel_Y1_e(x, result);
result->val *= sign;
return status;
}
else {
if(x <= 0.0) {
DOMAIN_ERROR(result);
}
if(x < 5.0) {
int status = bessel_Yn_small_x(n, x, result);
result->val *= sign;
return status;
}
else if(GSL_ROOT3_DBL_EPSILON * x > (n*n + 1.0)) {
int status = gsl_sf_bessel_Ynu_asympx_e((double)n, x, result);
result->val *= sign;
return status;
}
else if(n > 50) {
int status = gsl_sf_bessel_Ynu_asymp_Olver_e((double)n, x, result);
result->val *= sign;
return status;
}
else {
double two_over_x = 2.0/x;
gsl_sf_result r_by;
gsl_sf_result r_bym;
int stat_1 = gsl_sf_bessel_Y1_e(x, &r_by);
int stat_0 = gsl_sf_bessel_Y0_e(x, &r_bym);
double bym = r_bym.val;
double by = r_by.val;
double byp;
int j;
for(j=1; j<n; j++) {
byp = j*two_over_x*by - bym;
bym = by;
by = byp;
}
result->val = sign * by;
result->err = fabs(result->val) * (fabs(r_by.err/r_by.val) + fabs(r_bym.err/r_bym.val));
result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);
return GSL_ERROR_SELECT_2(stat_1, stat_0);
}
}
}
/* Evaluate J_mu(x),J_{mu+1}(x) and Y_mu(x),Y_{mu+1}(x) for |mu| < 1/2
*/
int
gsl_sf_bessel_JY_mu_restricted(const double mu, const double x,
gsl_sf_result * Jmu, gsl_sf_result * Jmup1,
gsl_sf_result * Ymu, gsl_sf_result * Ymup1)
{
/* CHECK_POINTER(Jmu) */
/* CHECK_POINTER(Jmup1) */
/* CHECK_POINTER(Ymu) */
/* CHECK_POINTER(Ymup1) */
if(x < 0.0 || fabs(mu) > 0.5) {
Jmu->val = 0.0;
Jmu->err = 0.0;
Jmup1->val = 0.0;
Jmup1->err = 0.0;
Ymu->val = 0.0;
Ymu->err = 0.0;
Ymup1->val = 0.0;
Ymup1->err = 0.0;
GSL_ERROR ("error", GSL_EDOM);
}
else if(x == 0.0) {
if(mu == 0.0) {
Jmu->val = 1.0;
Jmu->err = 0.0;
}
else {
Jmu->val = 0.0;
Jmu->err = 0.0;
}
Jmup1->val = 0.0;
Jmup1->err = 0.0;
Ymu->val = 0.0;
Ymu->err = 0.0;
Ymup1->val = 0.0;
Ymup1->err = 0.0;
GSL_ERROR ("error", GSL_EDOM);
}
else {
int stat_Y;
int stat_J;
if(x < 2.0) {
/* Use Taylor series for J and the Temme series for Y.
* The Taylor series for J requires nu > 0, so we shift
* up one and use the recursion relation to get Jmu, in
* case mu < 0.
*/
gsl_sf_result Jmup2;
int stat_J1 = gsl_sf_bessel_IJ_taylor_e(mu+1.0, x, -1, 100, GSL_DBL_EPSILON, Jmup1);
int stat_J2 = gsl_sf_bessel_IJ_taylor_e(mu+2.0, x, -1, 100, GSL_DBL_EPSILON, &Jmup2);
double c = 2.0*(mu+1.0)/x;
Jmu->val = c * Jmup1->val - Jmup2.val;
Jmu->err = c * Jmup1->err + Jmup2.err;
Jmu->err += 2.0 * GSL_DBL_EPSILON * fabs(Jmu->val);
stat_J = GSL_ERROR_SELECT_2(stat_J1, stat_J2);
stat_Y = gsl_sf_bessel_Y_temme(mu, x, Ymu, Ymup1);
return GSL_ERROR_SELECT_2(stat_J, stat_Y);
}
else if(x < 1000.0) {
double P, Q;
double J_ratio;
double J_sgn;
const int stat_CF1 = gsl_sf_bessel_J_CF1(mu, x, &J_ratio, &J_sgn);
const int stat_CF2 = gsl_sf_bessel_JY_steed_CF2(mu, x, &P, &Q);
double Jprime_J_ratio = mu/x - J_ratio;
double gamma = (P - Jprime_J_ratio)/Q;
Jmu->val = J_sgn * sqrt(2.0/(M_PI*x) / (Q + gamma*(P-Jprime_J_ratio)));
Jmu->err = 4.0 * GSL_DBL_EPSILON * fabs(Jmu->val);
Jmup1->val = J_ratio * Jmu->val;
Jmup1->err = fabs(J_ratio) * Jmu->err;
Ymu->val = gamma * Jmu->val;
Ymu->err = fabs(gamma) * Jmu->err;
Ymup1->val = Ymu->val * (mu/x - P - Q/gamma);
Ymup1->err = Ymu->err * fabs(mu/x - P - Q/gamma) + 4.0*GSL_DBL_EPSILON*fabs(Ymup1->val);
return GSL_ERROR_SELECT_2(stat_CF1, stat_CF2);
}
else {
/* Use asymptotics for large argument.
*/
const int stat_J0 = gsl_sf_bessel_Jnu_asympx_e(mu, x, Jmu);
const int stat_J1 = gsl_sf_bessel_Jnu_asympx_e(mu+1.0, x, Jmup1);
const int stat_Y0 = gsl_sf_bessel_Ynu_asympx_e(mu, x, Ymu);
const int stat_Y1 = gsl_sf_bessel_Ynu_asympx_e(mu+1.0, x, Ymup1);
stat_J = GSL_ERROR_SELECT_2(stat_J0, stat_J1);
stat_Y = GSL_ERROR_SELECT_2(stat_Y0, stat_Y1);
return GSL_ERROR_SELECT_2(stat_J, stat_Y);
}
}
}
