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 Error
_pack2frac(
floatnum x,
p_ext_seq_desc n,
int digits)
{
floatstruct tmp;
int exp;
Error result;
n->seq.digits -= n->seq.trailing0;
n->seq.trailing0 = 0;
switch(n->seq.base)
{
case IO_BASE_NAN:
float_setnan(x);
break;
case IO_BASE_ZERO:
float_setzero(x);
break;
default:
if ((result = _pack2int(x, n)) != Success)
return result;
float_create(&tmp);
float_setinteger(&tmp, n->seq.base);
_raiseposi(&tmp, &exp, n->seq.digits, digits+2);
float_div(x, x, &tmp, digits + 2);
float_setexponent(x, float_getexponent(x) - exp);
float_free(&tmp);
}
n->seq.digits += n->seq.trailing0;
return Success;
}
static Error
_packdec2int(
floatnum x,
p_ext_seq_desc n)
{
int ofs;
int exp;
int bufsz;
int i;
char buf[DECPRECISION];
float_setnan(x);
ofs = n->seq.leadingSignDigits;
exp = n->seq.trailing0;
bufsz = n->seq.digits - ofs - exp;
if (bufsz > DECPRECISION)
return IOBufferOverflow;
if (bufsz == 0)
float_setzero(x);
else
for (i = -1; ++i < bufsz;)
buf[i] = n->getdigit(ofs++, &n->seq) + '0';
float_setsignificand(x, NULL, buf, bufsz);
float_setexponent(x, exp + bufsz - 1);
return Success;
}
void
_cos(
floatnum x,
int digits)
{
signed char sgn;
float_abs(x);
sgn = 1;
if (float_cmp(x, &cPiDiv2) > 0)
{
sgn = -1;
float_sub(x, &cPi, x, digits+1);
}
if (float_cmp(x, &cPiDiv4) <= 0)
{
if (2*float_getexponent(x)+2 < - digits)
float_setzero(x);
else
_cosminus1ltPiDiv4(x, digits);
float_add(x, x, &c1, digits);
}
else
{
float_sub(x, &cPiDiv2, x, digits+1);
_sinltPiDiv4(x, digits);
}
float_setsign(x, sgn);
}
/* series expansion of cos/cosh - 1 used for small x,
|x| <= 0.01.
The function returns 0, if an underflow occurs.
The relative error seems to be less than 5e-100 for
a 100-digit calculation with |x| < 0.01 */
char
cosminus1series(
floatnum x,
int digits,
char alternating)
{
floatstruct sum, smd;
int expsqrx, pwrsz, addsz, i;
expsqrx = 2 * float_getexponent(x);
float_setexponent(x, 0);
float_mul(x, x, x, digits+1);
float_mul(x, x, &c1Div2, digits+1);
float_setsign(x, alternating? -1 : 1);
expsqrx += float_getexponent(x);
if (float_iszero(x) || expsqrx < EXPMIN)
{
/* underflow */
float_setzero(x);
return expsqrx == 0;
}
float_setexponent(x, expsqrx);
pwrsz = digits + expsqrx + 2;
if (pwrsz <= 0)
/* for very small x, cos/cosh(x) - 1 = (-/+)0.5*x*x */
return 1;
addsz = pwrsz;
float_create(&sum);
float_create(&smd);
float_copy(&smd, x, pwrsz);
float_setzero(&sum);
i = 2;
while (pwrsz > 0)
{
float_mul(&smd, &smd, x, pwrsz+1);
float_divi(&smd, &smd, i*(2*i-1), pwrsz);
float_add(&sum, &sum, &smd, addsz);
++i;
pwrsz = digits + float_getexponent(&smd);
}
float_add(x, x, &sum, digits+1);
float_free(&sum);
float_free(&smd);
return 1;
}
Error
pack2floatnum(
floatnum x,
p_number_desc n)
{
floatstruct tmp;
int digits;
int saveerr;
int saverange;
Error result;
signed char base;
if ((result = _pack2int(x, &n->intpart)) != Success)
return result;
if (float_isnan(x))
return Success;
saveerr = float_geterror();
saverange = float_setrange(MAXEXP);
float_create(&tmp);
float_move(&tmp, x);
float_setzero(x);
digits = DECPRECISION - float_getexponent(&tmp);
if (digits <= 0
|| (result = _pack2frac(x, &n->fracpart, digits)) == Success)
float_add(x, x, &tmp, DECPRECISION);
if (result != Success)
return result;
if ((!float_getlength(x)) == 0) /* no zero, no NaN? */
{
base = n->prefix.base;
float_setinteger(&tmp, base);
if (n->exp >= 0)
{
_raiseposi_(&tmp, n->exp, DECPRECISION + 2);
float_mul(x, x, &tmp, DECPRECISION + 2);
}
else
{
_raiseposi_(&tmp, -n->exp, DECPRECISION + 2);
float_div(x, x, &tmp, DECPRECISION + 2);
}
}
float_free(&tmp);
float_setsign(x, n->prefix.sign == IO_SIGN_COMPLEMENT? -1 : n->prefix.sign);
float_geterror();
float_seterror(saveerr);
float_setrange(saverange);
if (!float_isvalidexp(float_getexponent(x)))
float_setnan(x);
return float_isnan(x)? IOExpOverflow : Success;
}
char
float_cosh(
floatnum x,
int digits)
{
int expx;
if (!chckmathparam(x, digits))
return 0;
expx = float_getexponent(x);
if (2*expx+2 <= -digits || !_coshminus1(x, digits+2*expx))
{
if (expx > 0)
return _seterror(x, Overflow);
float_setzero(x);
}
return float_add(x, x, &c1, digits);
}
static Error
_pack2int(
floatnum x,
p_ext_seq_desc n)
{
switch(n->seq.base)
{
case IO_BASE_NAN:
float_setnan(x);
break;
case IO_BASE_ZERO:
float_setzero(x);
break;
case 10:
return _packdec2int(x, n);
default:
return _packbin2int(x, n);
}
return Success;
}
void
_longint2floatnum(
floatnum f,
t_longint* longint)
{
floatstruct tmp;
int idx;
float_setzero(f);
if(longint->length == 0)
return;
float_create(&tmp);
idx = longint->length - 1;
for (; idx >= 0; --idx)
{
_setunsigned(&tmp, longint->value[idx]);
float_mul(f, f, &cUnsignedBound, EXACT);
float_add(f, f, &tmp, EXACT);
}
float_free(&tmp);
}
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;
}
static char
_pochhammer_g(
floatnum x,
cfloatnum n,
int digits)
{
/* this generalizes the rising Pochhammer symbol using the
formula pochhammer(x,n) = Gamma(x+1)/Gamma(x-n+1) */
floatstruct tmp, factor1, factor2;
int inf1, inf2;
char result;
float_create(&tmp);
float_create(&factor1);
float_create(&factor2);
inf2 = 0;
float_add(&tmp, x, n, digits+1);
result = _lngamma_prim(x, &factor1, &inf1, digits)
&& _lngamma_prim(&tmp, &factor2, &inf2, digits)
&& (inf2 -= inf1) <= 0;
if (inf2 > 0)
float_seterror(ZeroDivide);
if (result && inf2 < 0)
float_setzero(x);
if (result && inf2 == 0)
result = float_div(&factor1, &factor1, &factor2, digits+1)
&& float_sub(x, &tmp, x, digits+1)
&& _exp(x, digits)
&& float_mul(x, x, &factor1, digits+1);
float_free(&tmp);
float_free(&factor2);
float_free(&factor1);
if (!result)
float_setnan(x);
return result;
}
/* the Taylor series of arctan/arctanh x at x == 0. For small
|x| < 0.01 this series converges very fast, yielding 4 or
more digits of the result with every summand. The working
precision is adjusted, so that the relative error for
100-digit arguments is around 5.0e-100. This means, the error
is 1 in the 100-th place (or less) */
void
arctanseries(
floatnum x,
int digits,
char alternating)
{
int expx;
int expsqrx;
int pwrsz;
int addsz;
int i;
floatstruct xsqr;
floatstruct pwr;
floatstruct smd;
floatstruct sum;
/* upper limit of log(x) and log(result) */
expx = float_getexponent(x)+1;
/* the summands of the series from the second on are
bounded by x^(2*i-1)/3. So the summation yields a
result bounded by (x^3/(1-x*x))/3.
For x < sqrt(1/3) approx.= 0.5, this is less than 0.5*x^3.
We need to sum up only, if the first <digits> places
of the result (roughly x) are touched. Ignoring the effect of
a possile carry, this is only the case, if
x*x >= 2*10^(-digits) > 10^(-digits)
Example: for x = 9e-51, a 100-digits result covers
the decimal places from 1e-51 to 1e-150. x^3/3
is roughly 3e-151, and so is the sum of the series.
So we can ignore the sum, but we couldn't for x = 9e-50 */
if (float_iszero(x) || 2*expx < -digits)
/* for very tiny arguments arctan/arctanh x is approx.== x */
return;
float_create(&xsqr);
float_create(&pwr);
float_create(&smd);
float_create(&sum);
/* we adapt the working precision to the decreasing
summands, saving time when multiplying. Unfortunately,
there is no error bound given for the operations of
bc_num. Tests show, that the last digit in an incomplete
multiplication is usually not correct up to 5 ULP's. */
pwrsz = digits + 2*expx + 1;
/* the precision of the addition must not decrease, of course */
addsz = pwrsz;
i = 3;
float_mul(&xsqr, x, x, pwrsz);
float_setsign(&xsqr, alternating? -1 : 1);
expsqrx = float_getexponent(&xsqr);
float_copy(&pwr, x, pwrsz);
float_setzero(&sum);
for(; pwrsz > 0; )
{
/* x^i */
float_mul(&pwr, &pwr, &xsqr, pwrsz+1);
/* x^i/i */
float_divi(&smd, &pwr, i, pwrsz);
/* The addition virtually does not introduce errors */
float_add(&sum, &sum, &smd, addsz);
/* reduce the working precision according to the decreasing powers */
pwrsz = digits - expx + float_getexponent(&smd) + expsqrx + 3;
i += 2;
}
/* add the first summand */
float_add(x, x, &sum, digits+1);
float_free(&xsqr);
float_free(&pwr);
float_free(&smd);
float_free(&sum);
}
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;
}