void
check_various (void)
{
mpf_t got;
mpq_t q;
mpf_init (got);
mpq_init (q);
/* 1/1 == 1 */
mpf_set_prec (got, 20L);
mpq_set_ui (q, 1L, 1L);
mpf_set_q (got, q);
MPF_CHECK_FORMAT (got);
ASSERT_ALWAYS (mpf_cmp_ui (got, 1L) == 0);
/* 1/(2^n+1), a case where truncating the divisor would be wrong */
mpf_set_prec (got, 500L);
mpq_set_ui (q, 1L, 1L);
mpz_mul_2exp (mpq_denref(q), mpq_denref(q), 800L);
mpz_add_ui (mpq_denref(q), mpq_denref(q), 1L);
check_one (got, q);
mpf_clear (got);
mpq_clear (q);
}
void
check_consistency (void)
{
mpf_t x;
unsigned long i, a, b;
mpf_init (x);
for (i = 1; i < 2000; i++)
{
mpf_set_prec (x, i);
a = mpf_get_prec (x);
mpf_set_prec (x, a);
b = mpf_get_prec (x);
if (a != b)
{
printf ("mpf_get_prec / mpf_set_prec inconsistent\n");
printf (" set %lu gives %lu, but then set %lu gives %lu\n",
i, a,
a, b);
abort ();
}
}
mpf_clear (x);
}
void
check_various (void)
{
mpf_t got, u, v;
mpf_init (got);
mpf_init (u);
mpf_init (v);
/* 100/4 == 25 */
mpf_set_prec (got, 20L);
mpf_set_ui (u, 100L);
mpf_set_ui (v, 4L);
mpf_div (got, u, v);
MPF_CHECK_FORMAT (got);
ASSERT_ALWAYS (mpf_cmp_ui (got, 25L) == 0);
/* 1/(2^n+1), a case where truncating the divisor would be wrong */
mpf_set_prec (got, 500L);
mpf_set_prec (v, 900L);
mpf_set_ui (v, 1L);
mpf_mul_2exp (v, v, 800L);
mpf_add_ui (v, v, 1L);
mpf_div (got, u, v);
check_one ("1/2^n+1, separate", got, u, v);
mpf_clear (got);
mpf_clear (u);
mpf_clear (v);
}
var Evalf(Var x, size_t y)
{
size_t z = mpf_get_default_prec();
mpf_set_default_prec((uint)(LOG_2_10 * y));
var r = Evalf(x);
mpf_set_default_prec(z);
if(FltQ(r)) mpf_set_prec(CFlt(r),(uint)(LOG_2_10 * y));
return r;
}
void determine_pivot_tolerances(mpf_t pivot_tol, mpf_t pivot_drop_tol, int prec)
/***************************************************************\
* USAGE: compute tolerances based on prec *
\***************************************************************/
{
int num_digits = (int) floor(prec * log10(2.0) - 2.5);
// setup pivot_tol
mpf_set_prec(pivot_tol, prec);
mpf_set_ui(pivot_tol, 10);
mpf_pow_ui(pivot_tol, pivot_tol, num_digits);
mpf_ui_div(pivot_tol, 1, pivot_tol);
// setup pivot_drop_tol
mpf_set_prec(pivot_drop_tol, prec);
mpf_set_ui(pivot_drop_tol, 10);
mpf_pow_ui(pivot_drop_tol, pivot_drop_tol, num_digits - 3);
return;
}
void precision_change_gmp(mpf_t x, mp_bitcnt_t p)
{
mpf_t tmp;
mpf_init2(tmp, p);
mpf_set(tmp, x);
mpf_set_prec( x, p);
mpf_set( x, tmp);
mpf_clear(tmp);
}
var Evalf(Var x)
{
switch(Type(x))
{
case TYPE(int):
{
var r = Flt();
F::SetZ(r,x);
return r;
}
break;
case TYPE(rat):
{
var r = Flt();
F::SetQ(r,x);
return r;
}
break;
case TYPE(flt):
{
var r = Flt();
F::Set(r,x);
mpf_set_prec(CFlt(r),mpf_get_default_prec());
return r;
}
break;
case TYPE(sym):
{
std::map<Var,attr_t>::const_iterator
iter = Attributes.find(x);
if(iter != Attributes.end() &&
iter->second.count(Constant))
return CProcs[x](0);
}
break;
case TYPE(vec):
{
size_t n = Size(x);
var r = Vec(n);
for(size_t i = 0; i < n; ++i)
At(r,i) = Evalf(At(x,i));
return r;
}
break;
case TYPE(ex):
{
var b = Evalf(Body(x));
return Eval(Ex(Head(x),b));
}
break;
}
return x;
}
static void
test_cmp_f (mpfr_prec_t pmin, mpfr_prec_t pmax, int nmax)
{
mpfr_t x, z;
mpf_t y;
mpfr_prec_t p;
int res1, res2;
int n;
mpfr_init (x);
mpfr_init2 (z, pmax+GMP_NUMB_BITS);
mpf_init2 (y, MPFR_PREC_MIN);
/* check the erange flag when x is NaN */
mpfr_set_nan (x);
mpf_set_ui (y, 17);
mpfr_clear_erangeflag ();
res1 = mpfr_cmp_f (x, y);
if (res1 != 0 || mpfr_erangeflag_p () == 0)
{
printf ("Error for mpfr_cmp_f (NaN, 17)\n");
printf ("Return value: expected 0, got %d\n", res1);
printf ("Erange flag: expected set, got %d\n", mpfr_erangeflag_p ());
exit (1);
}
for(p=pmin ; p < pmax ; p+=3)
{
mpfr_set_prec (x, p);
mpf_set_prec (y, p);
for ( n = 0; n < nmax ; n++)
{
mpfr_urandomb (x, RANDS);
mpf_urandomb (y, RANDS, p);
if (!MPFR_IS_SINGULAR (x))
{
mpfr_set_f (z, y, MPFR_RNDN);
mpfr_sub (z, x, z, MPFR_RNDN);
res1 = mpfr_sgn (z);
res2 = mpfr_cmp_f (x, y);
if (res1 != res2)
{
printf("Error for mpfr_cmp_f: res=%d sub gives %d\n",
res2, res1);
exit (1);
}
}
}
}
mpf_clear (y);
mpfr_clear (x);
mpfr_clear (z);
}
libmaus2::math::GmpFloat & libmaus2::math::GmpFloat::operator=(
GmpFloat const &
#if defined(LIBMAUS2_HAVE_GMP)
o
#endif
)
{
#if defined(LIBMAUS2_HAVE_GMP)
if ( this != &o )
{
mpf_set_prec(decode(v),mpf_get_prec(decode(o.v)));
mpf_set(decode(v),decode(o.v));
}
#endif
return *this;
}
static void
test_cmp_f (mpfr_prec_t pmin, mpfr_prec_t pmax, int nmax)
{
mpfr_t x, z;
mpf_t y;
mpfr_prec_t p;
int res1, res2;
int n;
mpfr_init (x);
mpfr_init2 (z, pmax+GMP_NUMB_BITS);
mpf_init2 (y, MPFR_PREC_MIN);
for(p=pmin ; p < pmax ; p+=3)
{
mpfr_set_prec (x, p);
mpf_set_prec (y, p);
for ( n = 0; n < nmax ; n++)
{
mpfr_urandomb (x, RANDS);
mpf_urandomb (y, RANDS, p);
if (!MPFR_IS_SINGULAR (x))
{
mpfr_set_f (z, y, MPFR_RNDN);
mpfr_sub (z, x, z, MPFR_RNDN);
res1 = mpfr_sgn (z);
res2 = mpfr_cmp_f (x, y);
if (res1 != res2)
{
printf("Error for mpfr_cmp_f: res=%d sub gives %d\n",
res2, res1);
exit (1);
}
}
}
}
mpf_clear (y);
mpfr_clear (x);
mpfr_clear (z);
}
static void
ternary_test (void)
{
int prec;
int rnd;
int inex, expected_inex;
mpf_t x;
mpfr_t y;
mpf_init2 (x, 256);
mpfr_init2 (y, 256);
for (prec = 2; prec <= 256; prec++)
{
mpf_set_prec (x, prec);
mpfr_set_prec (y, PREC (x) * GMP_NUMB_BITS + 1);
/* y == 1 */
mpfr_set_ui_2exp (y, 1, prec, MPFR_RNDN);
RND_LOOP (rnd)
{
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (inex != 0 || mpfr_cmp_f (y, x) !=0)
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
if (inex != 0)
printf ("got ternary value = %+d, expected: 0\n", inex);
exit (1);
}
}
/* y == 1 + epsilon */
mpfr_nextbelow (y);
RND_LOOP (rnd)
{
switch (rnd)
{
case MPFR_RNDU: case MPFR_RNDA:
case MPFR_RNDN:
expected_inex = +1;
break;
default :
expected_inex = -1;
}
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (! SAME_SIGN (expected_inex, inex)
|| SAME_SIGN (expected_inex, mpfr_cmp_f (y, x)))
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
if (! SAME_SIGN (expected_inex, inex))
printf ("got ternary value = %+d, expected: %+d\n",
inex, expected_inex);
exit (1);
}
}
/* y == positive random float */
mpfr_random2 (y, MPFR_LIMB_SIZE (y), 1024, RANDS);
RND_LOOP (rnd)
{
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (! SAME_SIGN (inex, -mpfr_cmp_f (y, x)))
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
printf ("got ternary value = %+d, expected: %+d\n",
inex, -mpfr_cmp_f (y, x));
exit (1);
}
}
}
mpf_clear (x);
mpfr_clear (y);
}
void mpfc_setdigits(mpfc_ptr x, uint digits)
{
mpf_set_prec(x->Im,(uint)(3.3219280948873623478703194294894 * digits));
mpf_set_prec(x->Re,(uint)(3.3219280948873623478703194294894 * digits));
}
int
main (int argc, char **argv)
{
mp_size_t size;
mp_exp_t exp;
int reps = 10000;
int i;
mpf_t u, v, w, x;
mp_size_t bprec = SIZE * GMP_LIMB_BITS;
mpf_t rerr, limit_rerr;
unsigned long ulimb, vlimb;
int single_flag;
tests_start ();
if (argc > 1)
{
reps = strtol (argv[1], 0, 0);
if (argc > 2)
bprec = strtol (argv[2], 0, 0);
}
mpf_set_default_prec (bprec);
mpf_init (rerr);
mpf_init (limit_rerr);
mpf_init (u);
mpf_init (v);
mpf_init (w);
mpf_init (x);
for (i = 0; i < reps; i++)
{
mp_size_t res_prec;
res_prec = urandom () % bprec + 1;
mpf_set_prec (w, res_prec);
mpf_set_prec (x, res_prec);
mpf_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, res_prec - 1);
single_flag = 0;
if ((urandom () & 1) != 0)
{
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % SIZE;
mpf_random2 (u, size, exp);
}
else
{
ulimb = urandom ();
mpf_set_ui (u, ulimb);
single_flag = 1;
}
if ((urandom () & 1) != 0)
{
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % SIZE;
mpf_random2 (v, size, exp);
}
else
{
vlimb = urandom ();
mpf_set_ui (v, vlimb);
single_flag = 2;
}
if (mpf_sgn (v) == 0)
continue;
mpf_div (w, u, v);
mpf_mul (x, w, v);
mpf_reldiff (rerr, u, x);
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR in mpf_mul or mpf_div after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf (" x = "); mpf_dump (x);
printf (" w = "); mpf_dump (w);
abort ();
}
if (single_flag == 2)
{
mpf_div_ui (x, u, vlimb);
mpf_reldiff (rerr, w, x);
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR in mpf_div or mpf_div_ui after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf (" x = "); mpf_dump (x);
printf (" w = "); mpf_dump (w);
abort ();
}
}
if (single_flag == 1)
{
mpf_ui_div (x, ulimb, v);
mpf_reldiff (rerr, w, x);
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR in mpf_div or mpf_ui_div after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf (" x = "); mpf_dump (x);
printf (" w = "); mpf_dump (w);
abort ();
}
}
}
mpf_clear (rerr);
mpf_clear (limit_rerr);
mpf_clear (u);
mpf_clear (v);
mpf_clear (w);
mpf_clear (x);
tests_end ();
exit (0);
}
int
main (void)
{
mpf_t x;
mpfr_t y, z;
unsigned long i;
mpfr_exp_t e;
int inex;
tests_start_mpfr ();
mpfr_init (y);
mpfr_init (z);
mpf_init (x);
i = 1;
while (i)
{
mpfr_set_ui (y, i, MPFR_RNDN);
if (mpfr_get_f (x, y, MPFR_RNDN) != 0 || mpf_cmp_ui (x, i))
{
printf ("Error: mpfr_get_f(%lu) fails\n", i);
exit (1);
}
if (i <= - (unsigned long) LONG_MIN)
{
long j = i < - (unsigned long) LONG_MIN ? - (long) i : LONG_MIN;
mpfr_set_si (y, j, MPFR_RNDN);
if (mpfr_get_f (x, y, MPFR_RNDN) != 0 || mpf_cmp_si (x, j))
{
printf ("Error: mpfr_get_f(-%lu) fails\n", i);
exit (1);
}
}
i *= 2;
}
/* same tests, but with a larger precision for y, which requires to
round it */
mpfr_set_prec (y, 100);
i = 1;
while (i)
{
mpfr_set_ui (y, i, MPFR_RNDN);
inex = mpfr_get_f (x, y, MPFR_RNDN);
if (! SAME_SIGN (inex, - mpfr_cmp_f (y, x)) || mpf_cmp_ui (x, i))
{
printf ("Error: mpfr_get_f(%lu) fails\n", i);
exit (1);
}
mpfr_set_si (y, (signed long) -i, MPFR_RNDN);
inex = mpfr_get_f (x, y, MPFR_RNDN);
if (! SAME_SIGN (inex, - mpfr_cmp_f (y, x))
|| mpf_cmp_si (x, (signed long) -i))
{
printf ("Error: mpfr_get_f(-%lu) fails\n", i);
exit (1);
}
i *= 2;
}
/* bug reported by Jim White */
for (e = 0; e <= 2 * GMP_NUMB_BITS; e++)
{
/* test with 2^(-e) */
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_div_2exp (y, y, e, MPFR_RNDN);
inex = mpfr_get_f (x, y, MPFR_RNDN);
mpf_mul_2exp (x, x, e);
if (inex != 0 || mpf_cmp_ui (x, 1) != 0)
{
printf ("Error: mpfr_get_f(x,y,MPFR_RNDN) fails\n");
printf ("y=");
mpfr_dump (y);
printf ("x=");
mpf_div_2exp (x, x, e);
mpf_out_str (stdout, 2, 0, x);
exit (1);
}
/* test with 2^(e) */
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_mul_2exp (y, y, e, MPFR_RNDN);
inex = mpfr_get_f (x, y, MPFR_RNDN);
mpf_div_2exp (x, x, e);
if (inex != 0 || mpf_cmp_ui (x, 1) != 0)
{
printf ("Error: mpfr_get_f(x,y,MPFR_RNDN) fails\n");
printf ("y=");
mpfr_dump (y);
printf ("x=");
mpf_mul_2exp (x, x, e);
mpf_out_str (stdout, 2, 0, x);
exit (1);
}
}
/* Bug reported by Yury Lukach on 2006-04-05 */
mpfr_set_prec (y, 32);
mpfr_set_prec (z, 32);
mpf_set_prec (x, 32);
mpfr_set_ui_2exp (y, 0xc1234567, -30, MPFR_RNDN);
mpfr_get_f (x, y, MPFR_RNDN);
inex = mpfr_set_f (z, x, MPFR_RNDN);
if (inex != 0 || ! mpfr_equal_p (y, z))
{
printf ("Error in mpfr_get_f:\n inex = %d, y = ", inex);
mpfr_dump (z);
printf ("Expected:\n inex = 0, y = ");
mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
mpfr_clear (z);
mpf_clear (x);
special_test ();
prec_test ();
ternary_test ();
tests_end_mpfr ();
return 0;
}
void setBits(int32_t bits) {
mpf_set_prec(mandelRange.minRe,bits);
mpf_set_prec(mandelRange.maxRe,bits);
mpf_set_prec(mandelRange.minIm,bits);
mpf_set_prec(mandelRange.maxIm,bits);
}
int
main (void)
{
mpfr_t x, u;
mpf_t y, z;
mpfr_exp_t emax;
unsigned long k, pr;
int r, inexact;
tests_start_mpfr ();
mpf_init (y);
mpf_init (z);
mpf_set_d (y, 0.0);
/* check prototype of mpfr_init_set_f */
mpfr_init_set_f (x, y, MPFR_RNDN);
mpfr_set_prec (x, 100);
mpfr_set_f (x, y, MPFR_RNDN);
mpf_urandomb (y, RANDS, 10 * GMP_NUMB_BITS);
mpfr_set_f (x, y, RND_RAND ());
/* bug found by Jean-Pierre Merlet */
mpfr_set_prec (x, 256);
mpf_set_prec (y, 256);
mpfr_init2 (u, 256);
mpfr_set_str (u,
"7.f10872b020c49ba5e353f7ced916872b020c49ba5e353f7ced916872b020c498@2",
16, MPFR_RNDN);
mpf_set_str (y, "2033033E-3", 10); /* avoid 2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=2033033E-3\n");
exit (1);
}
mpf_set_str (y, "-2033033E-3", 10); /* avoid -2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_neg (u, u, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=-2033033E-3\n");
exit (1);
}
mpf_set_prec (y, 300);
mpf_set_str (y, "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", -2);
mpf_mul_2exp (y, y, 600);
mpfr_set_prec (x, 300);
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_check (x) == 0)
{
printf ("Error in mpfr_set_f: corrupted result\n");
mpfr_dump (x);
exit (1);
}
MPFR_ASSERTN(mpfr_cmp_ui_2exp (x, 1, 901) == 0);
/* random values */
for (k = 1; k <= 1000; k++)
{
pr = 2 + (randlimb () & 255);
mpf_set_prec (z, pr);
mpf_urandomb (z, RANDS, z->_mp_prec);
mpfr_set_prec (u, ((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_set_f (u, z, MPFR_RNDN);
if (mpfr_cmp_f (u , z) != 0)
{
printf ("Error in mpfr_set_f:\n");
printf ("mpf (precision=%lu)=", pr);
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr(precision=%lu)=",
((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_out_str (stdout, 16, 0, u, MPFR_RNDN);
putchar ('\n');
exit (1);
}
mpfr_set_prec (x, pr);
mpfr_set_f (x, z, MPFR_RNDN);
mpfr_sub (u, u, x, MPFR_RNDN);
mpfr_abs (u, u, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (u, 1, -pr - 1) > 0)
{
printf ("Error in mpfr_set_f: precision=%lu\n", pr);
printf ("mpf =");
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr=");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
}
/* Check for +0 */
mpfr_set_prec (x, 53);
mpf_set_prec (y, 53);
mpf_set_ui (y, 0);
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
int i;
for (i = -1; i <= 1; i++)
{
if (i)
mpfr_set_si (x, i, MPFR_RNDN);
inexact = mpfr_set_f (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact)
{
printf ("mpfr_set_f(x,0) failed for %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
exit (1);
}
}
}
/* coverage test */
mpf_set_prec (y, 2);
mpfr_set_prec (x, 3 * mp_bits_per_limb);
mpf_set_ui (y, 1);
for (r = 0; r < mp_bits_per_limb; r++)
{
mpfr_urandomb (x, RANDS); /* to fill low limbs with random data */
inexact = mpfr_set_f (x, y, MPFR_RNDN);
MPFR_ASSERTN(inexact == 0 && mpfr_cmp_ui_2exp (x, 1, r) == 0);
mpf_mul_2exp (y, y, 1);
}
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, ULONG_MAX);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui (u, 1, MPFR_RNDN);
mpfr_mul_2ui (u, u, ULONG_MAX, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^ULONG_MAX\n");
exit (1);
}
emax = mpfr_get_emax ();
/* For mpf_mul_2exp, emax must fit in an unsigned long! */
if (emax >= 0 && emax <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^emax\n");
exit (1);
}
}
/* For mpf_mul_2exp, emax - 1 must fit in an unsigned long! */
if (emax >= 1 && emax - 1 <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax - 1);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax - 1, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^(emax-1)\n");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (u);
mpf_clear (y);
mpf_clear (z);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char **argv)
{
int reps = 100000;
int i;
mpf_t u, v, w1, w2, w3;
mp_size_t bprec = 100;
mpf_t rerr, limit_rerr;
mp_size_t un;
mp_exp_t ue;
tests_start ();
if (argc > 1)
{
reps = strtol (argv[1], 0, 0);
if (argc > 2)
bprec = strtol (argv[2], 0, 0);
}
mpf_set_default_prec (bprec);
mpf_init (rerr);
mpf_init (limit_rerr);
mpf_init (u);
mpf_init (v);
mpf_init (w1);
mpf_init (w2);
mpf_init (w3);
for (i = 0; i < reps; i++)
{
unsigned long int res_prec;
unsigned long int pow2;
res_prec = urandom () % (bprec + 100);
mpf_set_prec (w1, res_prec);
mpf_set_prec (w2, res_prec);
mpf_set_prec (w3, res_prec);
mpf_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, res_prec);
pow2 = urandom () % 0x10000;
mpf_set_ui (v, 1);
mpf_mul_2exp (v, v, pow2);
un = urandom () % (2 * SIZE) - SIZE;
ue = urandom () % SIZE;
mpf_random2 (u, un, ue);
mpf_div_2exp (w1, u, pow2);
mpf_div (w2, u, v);
mpf_reldiff (rerr, w1, w2);
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR in mpf_div or mpf_div_2exp after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf (" w1 = "); mpf_dump (w1);
printf (" w2 = "); mpf_dump (w2);
abort ();
}
mpf_mul_2exp (w3, w1, pow2);
mpf_reldiff (rerr, u, w3);
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR in mpf_mul_2exp after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf (" w1 = "); mpf_dump (w1);
printf (" w3 = "); mpf_dump (w3);
abort ();
}
}
mpf_clear (rerr);
mpf_clear (limit_rerr);
mpf_clear (u);
mpf_clear (v);
mpf_clear (w1);
mpf_clear (w2);
mpf_clear (w3);
tests_end ();
exit (0);
}
void FractalTexture::setPrecision(long numBits) {
#ifdef ROE_FRACTAL_USE_GMP
#ifdef ROE_FRACTAL_GMP_USE_C
mpf_set_prec(m_xUpLt , numBits);
mpf_set_prec(m_yUpLt , numBits);
mpf_set_prec(m_xCenter, numBits);
mpf_set_prec(m_yCenter, numBits);
mpf_set_prec(m_width , numBits);
mpf_set_prec(m_height , numBits);
mpf_set_prec(m_xPos , numBits);
mpf_set_prec(m_yPos , numBits);
mpf_set_prec(xPos , numBits);
mpf_set_prec(yPos , numBits);
mpf_set_prec(xPos2 , numBits);
mpf_set_prec(yPos2 , numBits);
mpf_set_prec(tmp , numBits);
#else
m_xUpLt.set_prec(numBits);
m_yUpLt.set_prec(numBits);
m_xCenter.set_prec(numBits);
m_yCenter.set_prec(numBits);
m_width.set_prec(numBits);
m_height.set_prec(numBits);
m_xPos.set_prec(numBits);
m_yPos.set_prec(numBits);
xPos.set_prec(numBits);
yPos.set_prec(numBits);
xPos2.set_prec(numBits);
yPos2.set_prec(numBits);
tmp.set_prec(numBits);
#endif
#endif
}
