double FunctionTable(std::string name,double val)
{
if( name == "log" )
return log10(val);
if( name == "ln" )
return log(val);
if( name == "abs" )
return abs(val);
if( name == "sqrt" )
return sqrt(val);
if( name == "sin" )
return sin(val);
if( name == "cos" )
return cos(val);
if( name == "tan" )
return tan(val);
if( name == "sinh" )
return sinh(val);
if( name == "cosh" )
return cosh(val);
if( name == "tanh" )
return tanh(val);
throw ArithmeticError(std::string(std::string("Unknown function ")+ name+"\n"));
return 0;
}
void SqrRoot(RR& z, const RR& a)
{
if (sign(a) < 0)
ArithmeticError("RR: attempt to take square root of negative number");
if (IsZero(a)) {
clear(z);
return;
}
RR t;
ZZ T1, T2;
long k;
k = 2*RR::prec - NumBits(a.x) + 1;
if (k < 0) k = 0;
if ((a.e - k) & 1) k++;
LeftShift(T1, a.x, k);
// since k >= 2*prec - bits(a) + 1, T1 has at least 2*prec+1 bits,
// thus T1 >= 2^(2*prec)
SqrRoot(t.x, T1); // t.x >= 2^prec thus t.x contains the round bit
t.e = (a.e - k)/2;
sqr(T2, t.x);
// T1-T2 is the (lower part of the) sticky bit
normalize(z, t, T2 < T1);
}
void conv(RR& z, double a)
{
if (a == 0) {
clear(z);
return;
}
if (a == 1) {
set(z);
return;
}
if (!IsFinite(&a))
ArithmeticError("RR: conversion of a non-finite double");
int e;
double f;
NTL_TLS_LOCAL(RR, t);
f = frexp(a, &e);
f = f * NTL_FDOUBLE_PRECISION;
f = f * 4;
conv(t.x, f);
t.e = e - (NTL_DOUBLE_PRECISION + 1);
xcopy(z, t);
}
double log(const xdouble& a)
{
static const double LogBound = log(NTL_XD_BOUND); // GLOBAL (assumes C++11 thread-safe init)
if (a.x <= 0) {
ArithmeticError("log(xdouble): argument must be positive");
}
return log(a.x) + a.e*LogBound;
}
void inv(mat_ZZ& X, const mat_ZZ& A)
{
ZZ d;
inv(d, X, A);
if (d == -1)
negate(X, X);
else if (d != 1)
ArithmeticError("inv: non-invertible matrix");
}
static
void ExactDiv(vec_ZZ& x, const ZZ& d)
{
long n = x.length();
long i;
for (i = 0; i < n; i++)
if (!divide(x[i], x[i], d))
ArithmeticError("inexact division");
}
xdouble operator/(const xdouble& a, const xdouble& b)
{
xdouble z;
if (b.x == 0) ArithmeticError("xdouble division by 0");
z.e = a.e - b.e;
z.x = a.x / b.x;
z.normalize();
return z;
}
static
void ExactDiv(mat_ZZ& x, const ZZ& d)
{
long n = x.NumRows();
long m = x.NumCols();
long i, j;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (!divide(x[i][j], x[i][j], d))
ArithmeticError("inexact division");
}
NTL_START_IMPL
GF2 power(GF2 a, long e)
{
if (e == 0) {
return to_GF2(1);
}
if (e < 0 && IsZero(a))
ArithmeticError("GF2: division by zero");
return a;
}
void DictionaryValue::sum(Value const &value)
{
DictionaryValue const *other = dynamic_cast<DictionaryValue const *>(&value);
if (!other)
{
throw ArithmeticError("DictionaryValue::sum", "Values cannot be summed");
}
for (Elements::const_iterator i = other->_elements.begin();
i != other->_elements.end(); ++i)
{
add(i->first.value->duplicate(), i->second->duplicate());
}
}
xdouble to_xdouble(double a)
{
if (a == 0 || a == 1 || (a > 0 && a >= NTL_XD_HBOUND_INV && a <= NTL_XD_HBOUND)
|| (a < 0 && a <= -NTL_XD_HBOUND_INV && a >= -NTL_XD_HBOUND)) {
return xdouble(a, 0);
}
if (!IsFinite(&a))
ArithmeticError("double to xdouble conversion: non finite value");
xdouble z = xdouble(a, 0);
z.normalize();
return z;
}
quad_float sqrt(const quad_float& y) {
if (y.hi < 0.0)
ArithmeticError("quad_float: square root of negative number");
if (y.hi == 0.0) return quad_float(0.0,0.0);
double c;
c = sqrt(y.hi);
ForceToMem(&c); // This is fairly paranoid, but it doesn't cost too much.
START_FIX
DOUBLE p,q,hx,tx,u,uu,cc;
DOUBLE t1;
p = Protect(NTL_QUAD_FLOAT_SPLIT*c);
hx = (c-p);
hx = hx+p;
tx = c-hx;
p = Protect(hx*hx);
q = Protect(hx*tx);
q = q+q;
u = p+q;
uu = p-u;
uu = uu+q;
t1 = Protect(tx*tx);
uu = uu+t1;
cc = y.hi-u;
cc = cc-uu;
cc = cc+y.lo;
t1 = c+c;
cc = cc/t1;
hx = c+cc;
tx = c-hx;
tx = tx+cc;
END_FIX
return quad_float(hx, tx);
}
xdouble sqrt(const xdouble& a)
{
if (a == 0)
return to_xdouble(0);
if (a < 0)
ArithmeticError("xdouble: sqrt of negative number");
xdouble t;
if (a.e & 1) {
t.e = (a.e - 1)/2;
t.x = sqrt(a.x * NTL_XD_BOUND);
}
else {
t.e = a.e/2;
t.x = sqrt(a.x);
}
t.normalize();
return t;
}
void div(RR& z, const RR& a, const RR& b)
{
if (IsZero(b))
ArithmeticError("RR: division by zero");
if (IsZero(a)) {
clear(z);
return;
}
long la = NumBits(a.x);
long lb = NumBits(b.x);
long neg = (sign(a) != sign(b));
long k = RR::prec - la + lb + 1;
if (k < 0) k = 0;
NTL_TLS_LOCAL(RR, t);
NTL_ZZRegister(A);
NTL_ZZRegister(B);
NTL_ZZRegister(R);
abs(A, a.x);
LeftShift(A, A, k);
abs(B, b.x);
DivRem(t.x, R, A, B);
t.e = a.e - b.e - k;
normalize(z, t, !IsZero(R));
if (neg)
negate(z.x, z.x);
}
void inv(mat_GF2E& X, const mat_GF2E& A)
{
GF2E d;
inv(d, X, A);
if (d == 0) ArithmeticError("inv: non-invertible matrix");
}
void inv(mat_ZZ_p& X, const mat_ZZ_p& A)
{
ZZ_p d;
inv(d, X, A);
if (d == 0) ArithmeticError("inv: non-invertible matrix");
}
