char
_gamma0_5(
floatnum x,
int digits)
{
floatstruct tmp;
int ofs;
if (float_getexponent(x) >= 2)
return _gamma(x, digits);
float_create(&tmp);
float_sub(&tmp, x, &c1Div2, EXACT);
ofs = float_asinteger(&tmp);
float_free(&tmp);
if (ofs >= 0)
{
float_copy(x, &c1Div2, EXACT);
if(!_pochhammer_su(x, ofs, digits))
return 0;
return float_mul(x, x, &cSqrtPi, digits);
}
if(!_pochhammer_su(x, -ofs, digits))
return 0;
return float_div(x, &cSqrtPi, x, digits);
}
char
_doshift(
floatnum dest,
cfloatnum x,
cfloatnum shift,
char right)
{
int ishift;
t_longint lx;
if (float_isnan(shift))
return _seterror(dest, NoOperand);
if (!float_isinteger(shift))
return _seterror(dest, OutOfDomain);
if(!_cvtlogic(&lx, x))
return 0;
if (float_iszero(shift))
{
float_copy(dest, x, EXACT);
return 1;
}
ishift = float_asinteger(shift);
if (ishift == 0)
ishift = (3*LOGICRANGE) * float_getsign(shift);
if (!right)
ishift = -ishift;
if (ishift > 0)
_shr(&lx, ishift);
else
_shl(&lx, -ishift);
_logic2floatnum(dest, &lx);
return 1;
}
/* returns how much x has to be increased to let the
asymptotic series converge to <digits> places */
static int
_ofs(
floatnum x,
int digits)
{
int result;
if (float_getexponent(x) >= 8)
return 0;
result = _minx(digits) - float_asinteger(x);
return result <= 0? 0 : result;
}
char
_gammaint(
floatnum integer,
int digits)
{
int ofs;
if (float_getexponent(integer) >=2)
return _gammagtminus20(integer, digits);
ofs = float_asinteger(integer);
float_copy(integer, &c1, EXACT);
return _pochhammer_su(integer, ofs-1, digits);
}
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;
}
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);
}
