char
binetasymptotic(floatnum x,
int digits)
{
floatstruct recsqr;
floatstruct sum;
floatstruct smd;
floatstruct pwr;
int i, workprec;
if (float_getexponent(x) >= digits)
{
/* if x is very big, ln(gamma(x)) is
dominated by x*ln x and the Binet function
does not contribute anything substantial to
the final result */
float_setzero(x);
return 1;
}
float_create(&recsqr);
float_create(&sum);
float_create(&smd);
float_create(&pwr);
float_copy(&pwr, &c1, EXACT);
float_setzero(&sum);
float_div(&smd, &c1, &c12, digits+1);
workprec = digits - 2*float_getexponent(x)+3;
i = 1;
if (workprec > 0)
{
float_mul(&recsqr, x, x, workprec);
float_reciprocal(&recsqr, workprec);
while (float_getexponent(&smd) > -digits-1
&& ++i <= MAXBERNOULLIIDX)
{
workprec = digits + float_getexponent(&smd) + 3;
float_add(&sum, &sum, &smd, digits+1);
float_mul(&pwr, &recsqr, &pwr, workprec);
float_muli(&smd, &cBernoulliDen[i-1], 2*i*(2*i-1), workprec);
float_div(&smd, &pwr, &smd, workprec);
float_mul(&smd, &smd, &cBernoulliNum[i-1], workprec);
}
}
else
/* sum reduces to the first summand*/
float_move(&sum, &smd);
if (i > MAXBERNOULLIIDX)
/* x was not big enough for the asymptotic
series to converge sufficiently */
float_setnan(x);
else
float_div(x, &sum, x, digits);
float_free(&pwr);
float_free(&smd);
float_free(&sum);
float_free(&recsqr);
return i <= MAXBERNOULLIIDX;
}
static int
_checkbounds(
floatnum x,
int digits,
signed char base)
{
if (float_getexponent(x) < 0)
{
float_muli(x, x, base, digits);
return -1;
}
else if (float_asinteger(x) >= base)
{
float_divi(x, x, base, digits);
return 1;
}
return 0;
}
char
erfcasymptotic(
floatnum x,
int digits)
{
floatstruct smd, fct;
int i, workprec, newprec;
float_create(&smd);
float_create(&fct);
workprec = digits - 2 * float_getexponent(x) + 1;
if (workprec <= 0)
{
float_copy(x, &c1, EXACT);
return 1;
}
float_mul(&fct, x, x, digits + 1);
float_div(&fct, &c1Div2, &fct, digits);
float_neg(&fct);
float_copy(&smd, &c1, EXACT);
float_setzero(x);
newprec = digits;
workprec = newprec;
i = 1;
while (newprec > 0 && newprec <= workprec)
{
workprec = newprec;
float_add(x, x, &smd, digits + 4);
float_muli(&smd, &smd, i, workprec + 1);
float_mul(&smd, &smd, &fct, workprec + 2);
newprec = digits + float_getexponent(&smd) + 1;
i += 2;
}
float_free(&fct);
float_free(&smd);
return newprec <= workprec;
}
char
erfcsum(
floatnum x, /* should be the square of the parameter to erfc */
int digits)
{
int i, workprec;
floatstruct sum, smd;
floatnum Ei;
if (digits > erfcdigits)
{
/* cannot re-use last evaluation's intermediate results */
for (i = MAXERFCIDX; --i >= 0;)
/* clear all exp(-k*k*alpha*alpha) to indicate their absence */
float_free(&erfccoeff[i]);
/* current precision */
erfcdigits = digits;
/* create new alpha appropriate for the desired precision
This alpha need not be high precision, any alpha near the
one evaluated here would do */
float_muli(&erfcalpha, &cLn10, digits + 4, 3);
float_sqrt(&erfcalpha, 3);
float_div(&erfcalpha, &cPi, &erfcalpha, 3);
float_mul(&erfcalphasqr, &erfcalpha, &erfcalpha, EXACT);
/* the exp(-k*k*alpha*alpha) are later evaluated iteratively.
Initiate the iteration here */
float_copy(&erfct2, &erfcalphasqr, EXACT);
float_neg(&erfct2);
_exp(&erfct2, digits + 3); /* exp(-alpha*alpha) */
float_copy(erfccoeff, &erfct2, EXACT); /* start value */
float_mul(&erfct3, &erfct2, &erfct2, digits + 3); /* exp(-2*alpha*alpha) */
}
float_create(&sum);
float_create(&smd);
float_setzero(&sum);
for (i = 0; ++i < MAXERFCIDX;)
{
Ei = &erfccoeff[i-1];
if (float_isnan(Ei))
{
/* if exp(-i*i*alpha*alpha) is not available, evaluate it from
the coefficient of the last summand */
float_mul(&erfct2, &erfct2, &erfct3, workprec + 3);
float_mul(Ei, &erfct2, &erfccoeff[i-2], workprec + 3);
}
/* Ei finally decays rapidly. save some time by adjusting the
working precision */
workprec = digits + float_getexponent(Ei) + 1;
if (workprec <= 0)
break;
/* evaluate the summand exp(-i*i*alpha*alpha)/(i*i*alpha*alpha+x) */
float_muli(&smd, &erfcalphasqr, i*i, workprec);
float_add(&smd, x, &smd, workprec + 2);
float_div(&smd, Ei, &smd, workprec + 1);
/* add summand to the series */
float_add(&sum, &sum, &smd, digits + 3);
}
float_move(x, &sum);
float_free(&smd);
return 1;
}
