char
_trigreduce(
floatnum x,
int digits)
{
floatstruct tmp;
int expx, save;
signed char sgn;
char odd;
if (float_abscmp(x, &cPi) <= 0)
return 1;
expx = float_getexponent(x);
if (expx > float_getlength(&cPi) - digits)
return 0;
save = float_setprecision(MAXDIGITS);
float_create(&tmp);
sgn = float_getsign(x);
float_abs(x);
float_divmod(&tmp, x, x, &cPi, INTQUOT);
float_setprecision(save);
odd = float_isodd(&tmp);
if (odd)
float_sub(x, x, &cPi, digits+1);
if (sgn < 0)
float_neg(x);
float_free(&tmp);
return 1;
}
static char
_lngamma_prim(
floatnum x,
floatnum revfactor,
int* infinity,
int digits)
{
floatstruct tmp;
char result;
char odd;
*infinity = 0;
if (float_getsign(x) > 0)
return _lngamma_prim_xgt0(x, revfactor, digits);
float_copy(revfactor, x, digits + 2);
float_sub(x, &c1, x, digits+2);
float_create(&tmp);
result = _lngamma_prim_xgt0(x, &tmp, digits);
if (result)
{
float_neg(x);
odd = float_isodd(revfactor);
_sinpix(revfactor, digits);
if (float_iszero(revfactor))
{
*infinity = 1;
float_setinteger(revfactor, odd? -1 : 1);
}
else
float_mul(&tmp, &tmp, &cPi, digits+2);
float_div(revfactor, revfactor, &tmp, digits+2);
}
float_free(&tmp);
return result;
}
static char
_pochhammer_i(
floatnum x,
cfloatnum n,
int digits)
{
/* do not use the expensive Gamma function when a few
multiplications do the same */
/* pre: n is an integer */
int ni;
signed char result;
if (float_iszero(n))
return float_copy(x, &c1, EXACT);
if (float_isinteger(x))
{
result = -1;
float_neg((floatnum)n);
if (float_getsign(x) <= 0 && float_cmp(x, n) > 0)
/* x and x+n have opposite signs, meaning 0 is
among the factors */
result = _setzero(x);
else if (float_getsign(x) > 0 && float_cmp(x, n) <= 0)
/* x and x+n have opposite signs, meaning at one point
you have to divide by 0 */
result = _seterror(x, ZeroDivide);
float_neg((floatnum)n);
if (result >= 0)
return result;
}
if (float_getexponent(x) < EXPMAX/100)
{
ni = float_asinteger(n);
if (ni != 0 && ni < 50 && ni > -50)
return _pochhammer_si(x, ni, digits+2);
}
return _pochhammer_g(x, n, digits);
}
void
_sinpix(
floatnum x,
int digits)
{
char odd;
odd = float_isodd(x);
float_frac(x);
float_mul(x, &cPi, x, digits+1);
_sin(x, digits);
if (odd)
float_neg(x);
}
int main() {
printf("Test with main.\n");
printf("bitAnd Result: %d\n", bitAnd(15,3));
printf("getByte Result: %d \n",getByte(0x12345678,22));
printf("bitcount Result: %d \n", bitCount(1));
printf("bang result is: %d \n", bang(3));
printf("minimum two's complement integer is: %d \n",tmin());
printf("fitbits result is: %d \n",fitsBits(-4,3));
printf("divpwr2 result is: %d \n",divpwr2(-33,4));
printf("negate result is: %d \n",negate(4));
printf("isPositive result is: %d \n",isPositive(-4));
printf("isLessOrEqual result is: %d \n",isLessOrEqual(5,5));
printf("float_neg result is: %d \n",float_neg(13));
printf("float_i2f result is: %d \n",float_i2f(15));
printf("float_twice result is: %d \n",float_twice(9.84));
}
char
float_artanhxplus1(
floatnum x,
int digits)
{
if (!chckmathparam(x, digits))
return 0;
if (float_getsign(x) >= 0 || float_abscmp(x, &c2) >= 0)
return _seterror(x, OutOfDomain);
if (float_cmp(x, &c1Div2) < 0)
{
float_neg(x);
_artanh1minusx(x, digits);
}
else
{
float_sub(x, &c1, x, digits+1);
_artanh(x, digits);
}
return 1;
}
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;
}
