int gsl_sf_bessel_Ynu_e(double nu, double x, gsl_sf_result * result) { /* CHECK_POINTER(result) */ if(x <= 0.0 || nu < 0.0) { DOMAIN_ERROR(result); } else if(nu > 50.0) { return gsl_sf_bessel_Ynu_asymp_Olver_e(nu, x, result); } else { /* -1/2 <= mu <= 1/2 */ int N = (int)(nu + 0.5); double mu = nu - N; gsl_sf_result Y_mu, Y_mup1; int stat_mu; double Ynm1; double Yn; double Ynp1; int n; if(x < 2.0) { /* Determine Ymu, Ymup1 directly. This is really * an optimization since this case could as well * be handled by a call to gsl_sf_bessel_JY_mu_restricted(), * as below. */ stat_mu = gsl_sf_bessel_Y_temme(mu, x, &Y_mu, &Y_mup1); } else { /* Determine Ymu, Ymup1 and Jmu, Jmup1. */ gsl_sf_result J_mu, J_mup1; stat_mu = gsl_sf_bessel_JY_mu_restricted(mu, x, &J_mu, &J_mup1, &Y_mu, &Y_mup1); } /* Forward recursion to get Ynu, Ynup1. */ Ynm1 = Y_mu.val; Yn = Y_mup1.val; for(n=1; n<=N; n++) { Ynp1 = 2.0*(mu+n)/x * Yn - Ynm1; Ynm1 = Yn; Yn = Ynp1; } result->val = Ynm1; /* Y_nu */ result->err = (N + 1.0) * fabs(Ynm1) * (fabs(Y_mu.err/Y_mu.val) + fabs(Y_mup1.err/Y_mup1.val)); result->err += 2.0 * GSL_DBL_EPSILON * fabs(Ynm1); return stat_mu; } }
/* 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); } } }
int gsl_sf_bessel_Jnu_e(const double nu, const double x, gsl_sf_result * result) { /* CHECK_POINTER(result) */ if(x < 0.0 || nu < 0.0) { DOMAIN_ERROR(result); } else if(x == 0.0) { if(nu == 0.0) { result->val = 1.0; result->err = 0.0; } else { result->val = 0.0; result->err = 0.0; } return GSL_SUCCESS; } else if(x*x < 10.0*(nu+1.0)) { return gsl_sf_bessel_IJ_taylor_e(nu, x, -1, 100, GSL_DBL_EPSILON, result); } else if(nu > 50.0) { return gsl_sf_bessel_Jnu_asymp_Olver_e(nu, x, result); } else { /* -1/2 <= mu <= 1/2 */ int N = (int)(nu + 0.5); double mu = nu - N; /* Determine the J ratio at nu. */ double Jnup1_Jnu; double sgn_Jnu; const int stat_CF1 = gsl_sf_bessel_J_CF1(nu, x, &Jnup1_Jnu, &sgn_Jnu); if(x < 2.0) { /* Determine Y_mu, Y_mup1 directly and recurse forward to nu. * Then use the CF1 information to solve for J_nu and J_nup1. */ gsl_sf_result Y_mu, Y_mup1; const int stat_mu = gsl_sf_bessel_Y_temme(mu, x, &Y_mu, &Y_mup1); double Ynm1 = Y_mu.val; double Yn = Y_mup1.val; double Ynp1 = 0.0; int n; for(n=1; n<N; n++) { Ynp1 = 2.0*(mu+n)/x * Yn - Ynm1; Ynm1 = Yn; Yn = Ynp1; } result->val = 2.0/(M_PI*x) / (Jnup1_Jnu*Yn - Ynp1); result->err = GSL_DBL_EPSILON * (N + 2.0) * fabs(result->val); return GSL_ERROR_SELECT_2(stat_mu, stat_CF1); } else { /* Recurse backward from nu to mu, determining the J ratio * at mu. Use this together with a Steed method CF2 to * determine the actual J_mu, and thus obtain the normalization. */ double Jmu; double Jmup1_Jmu; double sgn_Jmu; double Jmuprime_Jmu; double P, Q; const int stat_CF2 = gsl_sf_bessel_JY_steed_CF2(mu, x, &P, &Q); double gamma; double Jnp1 = sgn_Jnu * GSL_SQRT_DBL_MIN * Jnup1_Jnu; double Jn = sgn_Jnu * GSL_SQRT_DBL_MIN; double Jnm1; int n; for(n=N; n>0; n--) { Jnm1 = 2.0*(mu+n)/x * Jn - Jnp1; Jnp1 = Jn; Jn = Jnm1; } Jmup1_Jmu = Jnp1/Jn; sgn_Jmu = GSL_SIGN(Jn); Jmuprime_Jmu = mu/x - Jmup1_Jmu; gamma = (P - Jmuprime_Jmu)/Q; Jmu = sgn_Jmu * sqrt(2.0/(M_PI*x) / (Q + gamma*(P-Jmuprime_Jmu))); result->val = Jmu * (sgn_Jnu * GSL_SQRT_DBL_MIN) / Jn; result->err = 2.0 * GSL_DBL_EPSILON * (N + 2.0) * fabs(result->val); return GSL_ERROR_SELECT_2(stat_CF2, stat_CF1); } } }