/// Carlson elliptic integrals R_C.
double
ellint_rc(double x, double y)
{
if (x == 0.0 && y == 0.0)
return 0.0;
const gsl_mode_t mode = GSL_PREC_DOUBLE;
gsl_sf_result result;
int stat = gsl_sf_ellint_RC_e(x, y, mode, &result);
if (stat != GSL_SUCCESS)
{
std::ostringstream msg("Error in ellint_rc:");
msg << " x=" << x << " y=" << y;
throw std::runtime_error(msg.str());
}
else
return result.val;
}
int
gsl_sf_ellint_RJ_e(double x, double y, double z, double p, gsl_mode_t mode, gsl_sf_result * result)
{
const gsl_prec_t goal = GSL_MODE_PREC(mode);
const double errtol = ( goal == GSL_PREC_DOUBLE ? 0.001 : 0.03 );
const double prec = gsl_prec_eps[goal];
const double lolim = pow(5.0 * GSL_DBL_MIN, 1.0/3.0);
const double uplim = 0.3 * pow(0.2 * GSL_DBL_MAX, 1.0/3.0);
if(x < 0.0 || y < 0.0 || z < 0.0) {
DOMAIN_ERROR(result);
}
else if(x + y < lolim || x + z < lolim || y + z < lolim || p < lolim) {
DOMAIN_ERROR(result);
}
else if(locMAX4(x,y,z,p) < uplim) {
const double c1 = 3.0 / 14.0;
const double c2 = 1.0 / 3.0;
const double c3 = 3.0 / 22.0;
const double c4 = 3.0 / 26.0;
double xn = x;
double yn = y;
double zn = z;
double pn = p;
double sigma = 0.0;
double power4 = 1.0;
double mu, xndev, yndev, zndev, pndev;
double ea, eb, ec, e2, e3, s1, s2, s3;
while(1) {
double xnroot, ynroot, znroot;
double lamda, alfa, beta;
double epslon;
gsl_sf_result rcresult;
int rcstatus;
mu = (xn + yn + zn + pn + pn) * 0.2;
xndev = (mu - xn) / mu;
yndev = (mu - yn) / mu;
zndev = (mu - zn) / mu;
pndev = (mu - pn) / mu;
epslon = locMAX4(fabs(xndev), fabs(yndev), fabs(zndev), fabs(pndev));
if(epslon < errtol) break;
xnroot = sqrt(xn);
ynroot = sqrt(yn);
znroot = sqrt(zn);
lamda = xnroot * (ynroot + znroot) + ynroot * znroot;
alfa = pn * (xnroot + ynroot + znroot) + xnroot * ynroot * znroot;
alfa = alfa * alfa;
beta = pn * (pn + lamda) * (pn + lamda);
rcstatus = gsl_sf_ellint_RC_e(alfa, beta, mode, &rcresult);
if(rcstatus != GSL_SUCCESS) {
result->val = 0.0;
result->err = 0.0;
return rcstatus;
}
sigma += power4 * rcresult.val;
power4 *= 0.25;
xn = (xn + lamda) * 0.25;
yn = (yn + lamda) * 0.25;
zn = (zn + lamda) * 0.25;
pn = (pn + lamda) * 0.25;
}
ea = xndev * (yndev + zndev) + yndev * zndev;
eb = xndev * yndev * zndev;
ec = pndev * pndev;
e2 = ea - 3.0 * ec;
e3 = eb + 2.0 * pndev * (ea - ec);
s1 = 1.0 + e2 * (- c1 + 0.75 * c3 * e2 - 1.5 * c4 * e3);
s2 = eb * (0.5 * c2 + pndev * (- c3 - c3 + pndev * c4));
s3 = pndev * ea * (c2 - pndev * c3) - c2 * pndev * ec;
result->val = 3.0 * sigma + power4 * (s1 + s2 + s3) / (mu * sqrt(mu));
result->err = prec * fabs(result->val);
return GSL_SUCCESS;
}
else {
DOMAIN_ERROR(result);
}
}
double gsl_sf_ellint_RC(double x, double y, gsl_mode_t mode)
{
EVAL_RESULT(gsl_sf_ellint_RC_e(x, y, mode, &result));
}
/**
* C++ version of gsl_sf_ellint_RC_e().
* Carlson's symmetric basis of functions
*
* RC(x,y) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1)], {t,0,Inf}]
* @param x A real number
* @param y A real number
* @param mode The mode
* @param result The result as a @c gsl::sf::result object
* @return GSL_SUCCESS or GSL_EDOM
*/
inline int RC_e( double x, double y, mode_t mode, result& result ){
return gsl_sf_ellint_RC_e( x, y, mode, &result ); }
