/* r = sqrt(x) */
void
my_sqrt_ui(mpf_t r, unsigned long x)
{
unsigned long prec, bits, prec0;
prec0 = mpf_get_prec(r);
if (prec0<=DOUBLE_PREC) {
mpf_set_d(r, sqrt(x));
return;
}
bits = 0;
for (prec=prec0; prec>DOUBLE_PREC;)
{
int bit = prec&1;
prec = (prec+bit)/2;
bits = bits*2+bit;
}
mpf_set_prec_raw(t1, DOUBLE_PREC);
mpf_set_d(t1, 1/sqrt(x));
while (prec<prec0)
{
prec *=2;
if (prec<prec0)
{
/* t1 = t1+t1*(1-x*t1*t1)/2; */
mpf_set_prec_raw(t2, prec);
mpf_mul(t2, t1, t1); /* half x half -> full */
mpf_mul_ui(t2, t2, x);
mpf_ui_sub(t2, 1, t2);
mpf_set_prec_raw(t2, prec/2);
mpf_div_2exp(t2, t2, 1);
mpf_mul(t2, t2, t1); /* half x half -> half */
mpf_set_prec_raw(t1, prec);
mpf_add(t1, t1, t2);
}
else
{
break;
}
prec -= (bits&1);
bits /=2;
}
/* t2=x*t1, t1 = t2+t1*(x-t2*t2)/2; */
mpf_set_prec_raw(t2, prec0/2);
mpf_mul_ui(t2, t1, x);
mpf_mul(r, t2, t2); /* half x half -> full */
mpf_ui_sub(r, x, r);
mpf_mul(t1, t1, r); /* half x half -> half */
mpf_div_2exp(t1, t1, 1);
mpf_add(r, t1, t2);
}
// r = sqrt(x)
void my_sqrt(mpf_t r, mpf_t x)
{
unsigned prec, bits, prec0;
prec0 = mpf_get_prec(r);
if (prec0 <= DOUBLE_PREC) {
mpf_set_d(r, sqrt(mpf_get_d(x)));
return;
}
bits = 0;
for (prec = prec0; prec > DOUBLE_PREC;) {
int bit = prec & 1;
prec = (prec + bit) / 2;
bits = bits * 2 + bit;
}
mpf_set_prec_raw(t1, DOUBLE_PREC);
mpf_set_d(t1, 1 / sqrt(mpf_get_d(x)));
while (prec < prec0) {
prec *= 2;
/*printf("prec=%d, prec0=%d\n", prec, prec0); */
if (prec < prec0) {
/* t1 = t1+t1*(1-x*t1*t1)/2; */
mpf_set_prec_raw(t2, prec);
mpf_mul(t2, t1, t1);
mpf_set_prec_raw(x, prec/2);
mpf_mul(t2, t2, x);
mpf_ui_sub(t2, 1, t2);
mpf_set_prec_raw(t2, prec/2);
mpf_div_2exp(t2, t2, 1);
mpf_mul(t2, t2, t1);
mpf_set_prec_raw(t1, prec);
mpf_add(t1, t1, t2);
} else {
prec = prec0;
/* t2=x*t1, t1 = t2+t1*(x-t2*t2)/2; */
mpf_set_prec_raw(t2, prec/2);
mpf_set_prec_raw(x, prec/2);
mpf_mul(t2, t1, x);
mpf_mul(r, t2, t2);
mpf_set_prec_raw(x, prec);
mpf_sub(r, x, r);
mpf_mul(t1, t1, r);
mpf_div_2exp(t1, t1, 1);
mpf_add(r, t1, t2);
break;
}
prec -= (bits & 1);
bits /= 2;
}
}
static void precision_init(int prec) {
int i;
mpf_t f0;
mpf_set_default_prec(prec);
mpf_init2(epsilon, 2);
mpf_init2(negepsilon, 2);
mpf_init(recipeulere);
mpf_init(pi);
mpf_init(eulere);
mpf_set_ui(epsilon, 1);
mpf_div_2exp(epsilon, epsilon, prec);
mpf_neg(negepsilon, epsilon);
mpf_init(f0);
mpf_set_ui(eulere, 1);
mpf_set_ui(f0, 1);
for (i=1;; i++) {
mpf_div_ui(f0, f0, i);
if (mpf_cmp(f0, epsilon) < 0) {
break;
}
mpf_add(eulere, eulere, f0);
}
mpf_clear(f0);
mpf_ui_div(recipeulere, 1, eulere);
compute_pi(prec);
}
static int is_small(const mpf_t x, const mpf_t y) {
DECLARE_2VARS(xa,ya);
mpf_abs(xa,x);
mpf_abs(ya,y);
mpf_div_2exp(ya,ya,PREC_BITS-mp_bits_per_limb);
return mpf_cmp(xa,ya) < 0;
}
void my_divexact(mpz_t r, mpz_t y, mpz_t x)
{
unsigned long prec = mpz_sizeinbase(y, 2);
unsigned long prec2 = mpz_sizeinbase(x, 2);
if (prec >= div_threshold) {
mpf_set_prec_raw(d1, prec);
mpf_set_prec_raw(d2, prec);
mpf_set_z(d1, y);
mpf_set_z(d2, x);
mpf_div_2exp(d1, d1, prec);
mpf_div_2exp(d2, d2, prec2);
my_div(d2, d1, d2);
mpf_mul_2exp(d2, d2, prec-prec2);
mpf_set_d(d1, 0.5);
mpf_add(d2, d2, d1);
mpz_set_f(y, d2);
} else {
mpz_divexact(y, y, x);
//mpz_tdiv_q(y, y, x);
}
}
int
main (void)
{
mpf_t f;
tests_start ();
mpf_init2 (f, 200L);
mpf_set_ui (f, 0L);
one (f, 1);
mpf_set_ui (f, 1L);
all (f, 1);
mpf_set_ui (f, 1L);
mpf_div_2exp (f, f, 1L);
all (f, 0);
mpf_set_ui (f, 1L);
mpf_div_2exp (f, f, 5000L);
all (f, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, 5000L);
all (f, 1);
mpf_set_str (f, "0.5", 10);
all (f, 0);
mpf_set_ui (f, 1L);
mpf_div_ui (f, f, 3L);
all (f, 0);
mpf_clear (f);
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;
}
int
main (void)
{
mpf_t f, f0p5;
int got;
const char *expr;
int error = 0;
tests_start ();
mpf_init2 (f, 200L);
mpf_init2 (f0p5, 200L);
/* 0.5 */
mpf_set_ui (f0p5, 1L);
mpf_div_2exp (f0p5, f0p5, 1L);
mpf_set_ui (f, 0L);
expr = "0";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_ui (f, 1L);
expr = "1";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, -1L);
expr = "-1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
expr = "USHRT_MAX";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
mpf_add (f, f, f0p5);
expr = "USHRT_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
mpf_add_ui (f, f, 1L);
expr = "USHRT_MAX + 1";
EXPECT (mpf_fits_ushort_p, 0);
mpf_set_ui (f, (unsigned long) UINT_MAX);
expr = "UINT_MAX";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
mpf_set_ui (f, (unsigned long) UINT_MAX);
mpf_add (f, f, f0p5);
expr = "UINT_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
mpf_set_ui (f, (unsigned long) UINT_MAX);
mpf_add_ui (f, f, 1L);
expr = "UINT_MAX + 1";
EXPECT (mpf_fits_uint_p, 0);
mpf_set_ui (f, ULONG_MAX);
expr = "ULONG_MAX";
EXPECT (mpf_fits_ulong_p, 1);
mpf_set_ui (f, ULONG_MAX);
mpf_add (f, f, f0p5);
expr = "ULONG_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
mpf_set_ui (f, ULONG_MAX);
mpf_add_ui (f, f, 1L);
expr = "ULONG_MAX + 1";
EXPECT (mpf_fits_ulong_p, 0);
mpf_set_si (f, (long) SHRT_MAX);
expr = "SHRT_MAX";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MAX);
expr = "SHRT_MAX + 0.5";
mpf_add (f, f, f0p5);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MAX);
mpf_add_ui (f, f, 1L);
expr = "SHRT_MAX + 1";
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_si (f, (long) INT_MAX);
expr = "INT_MAX";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MAX);
mpf_add (f, f, f0p5);
expr = "INT_MAX + 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MAX);
mpf_add_ui (f, f, 1L);
expr = "INT_MAX + 1";
EXPECT (mpf_fits_sint_p, 0);
mpf_set_si (f, LONG_MAX);
expr = "LONG_MAX";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MAX);
mpf_add (f, f, f0p5);
expr = "LONG_MAX + 0.5";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MAX);
mpf_add_ui (f, f, 1L);
expr = "LONG_MAX + 1";
EXPECT (mpf_fits_slong_p, 0);
mpf_set_si (f, (long) SHRT_MIN);
expr = "SHRT_MIN";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MIN);
mpf_sub (f, f, f0p5);
expr = "SHRT_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MIN);
mpf_sub_ui (f, f, 1L);
expr = "SHRT_MIN + 1";
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_si (f, (long) INT_MIN);
expr = "INT_MIN";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MIN);
mpf_sub (f, f, f0p5);
expr = "INT_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MIN);
mpf_sub_ui (f, f, 1L);
expr = "INT_MIN + 1";
EXPECT (mpf_fits_sint_p, 0);
mpf_set_si (f, LONG_MIN);
expr = "LONG_MIN";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MIN);
mpf_sub (f, f, f0p5);
expr = "LONG_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MIN);
mpf_sub_ui (f, f, 1L);
expr = "LONG_MIN + 1";
EXPECT (mpf_fits_slong_p, 0);
mpf_set_str_or_abort (f, "0.5", 10);
expr = "0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "-0.5", 10);
expr = "-0.5";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "1.000000000000000000000000000000000001", 16);
expr = "1.000000000000000000000000000000000001 base 16";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "1@1000", 16);
expr = "1@1000 base 16";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 1);
mpf_sub_ui (f, f, 1L);
expr = "2^(BITS_PER_ULONG+1) - 1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 1);
mpf_sub_ui (f, f, 1L);
mpf_neg (f, f);
expr = "- (2^(BITS_PER_ULONG+1) - 1)";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 5);
mpf_sub_ui (f, f, 1L);
expr = "2^(BITS_PER_ULONG+5) - 1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
if (error)
abort ();
mpf_clear (f);
mpf_clear (f0p5);
tests_end ();
exit (0);
}
void
check_one (mpz_srcptr z)
{
static const int shift[] = {
0, 1, BITS_PER_MP_LIMB, 2*BITS_PER_MP_LIMB, 5*BITS_PER_MP_LIMB
};
int sh, shneg, neg;
mpf_t f;
mpz_t got, want;
mpf_init2 (f, mpz_sizeinbase(z,2));
mpz_init (got);
mpz_init (want);
for (sh = 0; sh < numberof(shift); sh++)
{
for (shneg = 0; shneg <= 1; shneg++)
{
for (neg = 0; neg <= 1; neg++)
{
mpf_set_z (f, z);
mpz_set (want, z);
if (neg)
{
mpf_neg (f, f);
mpz_neg (want, want);
}
if (shneg)
{
mpz_tdiv_q_2exp (want, want, shift[sh]);
mpf_div_2exp (f, f, shift[sh]);
}
else
{
mpz_mul_2exp (want, want, shift[sh]);
mpf_mul_2exp (f, f, shift[sh]);
}
mpz_set_f (got, f);
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("wrong result\n");
printf (" shift %d\n", shneg ? -shift[sh] : shift[sh]);
printf (" neg %d\n", neg);
mpf_trace (" f", f);
mpz_trace (" got", got);
mpz_trace (" want", want);
abort ();
}
}
}
}
mpf_clear (f);
mpz_clear (got);
mpz_clear (want);
}
void
check_various (void)
{
mpf_t src, trunc, ceil, floor;
int n, i;
mpf_init2 (src, 512L);
mpf_init2 (trunc, 256L);
mpf_init2 (ceil, 256L);
mpf_init2 (floor, 256L);
/* 0 */
mpf_set_ui (src, 0L);
mpf_set_ui (trunc, 0L);
mpf_set_ui (ceil, 0L);
mpf_set_ui (floor, 0L);
check_all (src, trunc, ceil, floor);
/* 1 */
mpf_set_ui (src, 1L);
mpf_set_ui (trunc, 1L);
mpf_set_ui (ceil, 1L);
mpf_set_ui (floor, 1L);
check_all (src, trunc, ceil, floor);
/* 2^1024 */
mpf_set_ui (src, 1L);
mpf_mul_2exp (src, src, 1024L);
mpf_set (trunc, src);
mpf_set (ceil, src);
mpf_set (floor, src);
check_all (src, trunc, ceil, floor);
/* 1/2^1024, fraction only */
mpf_set_ui (src, 1L);
mpf_div_2exp (src, src, 1024L);
mpf_set_si (trunc, 0L);
mpf_set_si (ceil, 1L);
mpf_set_si (floor, 0L);
check_all (src, trunc, ceil, floor);
/* 1/2 */
mpf_set_ui (src, 1L);
mpf_div_2exp (src, src, 1L);
mpf_set_si (trunc, 0L);
mpf_set_si (ceil, 1L);
mpf_set_si (floor, 0L);
check_all (src, trunc, ceil, floor);
/* 123+1/2^64 */
mpf_set_ui (src, 1L);
mpf_div_2exp (src, src, 64L);
mpf_add_ui (src, src, 123L);
mpf_set_si (trunc, 123L);
mpf_set_si (ceil, 124L);
mpf_set_si (floor, 123L);
check_all (src, trunc, ceil, floor);
/* integer of full prec+1 limbs, unchanged */
n = PREC(trunc)+1;
ASSERT_ALWAYS (n <= PREC(src)+1);
EXP(src) = n;
SIZ(src) = n;
for (i = 0; i < SIZ(src); i++)
PTR(src)[i] = i+100;
mpf_set (trunc, src);
mpf_set (ceil, src);
mpf_set (floor, src);
check_all (src, trunc, ceil, floor);
/* full prec+1 limbs, 1 trimmed for integer */
n = PREC(trunc)+1;
ASSERT_ALWAYS (n <= PREC(src)+1);
EXP(src) = n-1;
SIZ(src) = n;
for (i = 0; i < SIZ(src); i++)
PTR(src)[i] = i+200;
EXP(trunc) = n-1;
SIZ(trunc) = n-1;
for (i = 0; i < SIZ(trunc); i++)
PTR(trunc)[i] = i+201;
mpf_set (floor, trunc);
mpf_add_ui (ceil, trunc, 1L);
check_all (src, trunc, ceil, floor);
/* prec+3 limbs, 2 trimmed for size */
n = PREC(trunc)+3;
ASSERT_ALWAYS (n <= PREC(src)+1);
EXP(src) = n;
SIZ(src) = n;
for (i = 0; i < SIZ(src); i++)
PTR(src)[i] = i+300;
EXP(trunc) = n;
SIZ(trunc) = n-2;
for (i = 0; i < SIZ(trunc); i++)
PTR(trunc)[i] = i+302;
mpf_set (floor, trunc);
mpf_set (ceil, trunc);
PTR(ceil)[0]++;
check_all (src, trunc, ceil, floor);
/* prec+4 limbs, 2 trimmed for size, 1 trimmed for integer */
n = PREC(trunc)+4;
ASSERT_ALWAYS (n <= PREC(src)+1);
EXP(src) = n-1;
SIZ(src) = n;
for (i = 0; i < SIZ(src); i++)
PTR(src)[i] = i+400;
EXP(trunc) = n-1;
SIZ(trunc) = n-3;
for (i = 0; i < SIZ(trunc); i++)
PTR(trunc)[i] = i+403;
mpf_set (floor, trunc);
mpf_set (ceil, trunc);
PTR(ceil)[0]++;
check_all (src, trunc, ceil, floor);
/* F.F, carry out of ceil */
EXP(src) = 1;
SIZ(src) = 2;
PTR(src)[0] = GMP_NUMB_MAX;
PTR(src)[1] = GMP_NUMB_MAX;
EXP(trunc) = 1;
SIZ(trunc) = 1;
PTR(trunc)[0] = GMP_NUMB_MAX;
mpf_set (floor, trunc);
EXP(ceil) = 2;
SIZ(ceil) = 1;
PTR(ceil)[0] = 1;
check_all (src, trunc, ceil, floor);
/* FF.F, carry out of ceil */
EXP(src) = 2;
SIZ(src) = 3;
PTR(src)[0] = GMP_NUMB_MAX;
PTR(src)[1] = GMP_NUMB_MAX;
PTR(src)[2] = GMP_NUMB_MAX;
EXP(trunc) = 2;
SIZ(trunc) = 2;
PTR(trunc)[0] = GMP_NUMB_MAX;
PTR(trunc)[1] = GMP_NUMB_MAX;
mpf_set (floor, trunc);
EXP(ceil) = 3;
SIZ(ceil) = 1;
PTR(ceil)[0] = 1;
check_all (src, trunc, ceil, floor);
mpf_clear (src);
mpf_clear (trunc);
mpf_clear (ceil);
mpf_clear (floor);
}
void topsin_series (mpf_t a_k, unsigned int k, unsigned int prec)
{
unsigned int n;
mpf_t fourpi, numer, fact, low_bound, term, xterm;
mpz_t bino;
mpf_set_ui(a_k, 0);
/* If k == 0 then we are done */
if (0 == k) return;
mpf_init(fourpi);
mpf_init(numer);
mpf_init(fact);
mpf_init(low_bound);
mpf_init(term);
mpf_init(xterm);
mpz_init(bino);
fp_two_pi(numer, prec);
mpf_neg(numer, numer);
// fourpi is actually -4pi^2
mpf_mul(fourpi, numer, numer);
mpf_neg(fourpi, fourpi);
mpf_set_ui(fact, 1);
/* Get the number of binary bits from prec = log_2 10 * prec */
long nbits = (long) floor (3.321 * prec);
mpf_div_2exp(low_bound, fact, nbits+32);
for (n=0; n<2023123123; n++)
{
i_binomial(bino, 2*n+k, 2*n);
mpf_set_z(term, bino);
mpf_mul(xterm, term, numer);
mpf_div(term, xterm, fact);
mpf_add(a_k, a_k, term);
// #define DEBUG 1
#ifdef DEBUG
{
double h_f, q_f, b_f;
h_f = mpf_get_d(h);
q_f = mpf_get_d(qmark);
b_f = mpf_get_d(bits);
printf("duuude place=%d, bitsdone=%ld h=%g q=%g bits=%f s=%d\n",
place, bitsdone, h_f, q_f, b_f, mpf_sgn(h));
}
#endif
// If the term is small enough, we are done.
mpf_abs(xterm, term);
if (mpf_cmp(xterm, low_bound) < 0) break;
// Now iterate
mpf_mul(numer, numer, fourpi);
mpf_mul_ui(fact, fact, (2*n+3)*2*(n+1));
}
if (k%2 == 0) mpf_neg(a_k, a_k);
mpf_clear(fourpi);
mpf_clear(numer);
mpf_clear(fact);
mpf_clear(low_bound);
mpf_clear(term);
mpf_clear(xterm);
mpz_clear(bino);
}
bool sum_test(double xf, int prec)
{
bool fail = false;
int k;
mpf_t a_k, x, xn, term, sum, sino, low_bound;
mpf_init(a_k);
mpf_init(x);
mpf_init(xn);
mpf_init(term);
mpf_init(sum);
mpf_init(sino);
mpf_init(low_bound);
long nbits = (long) floor (3.321 * prec);
mpf_set_ui(x, 1);
mpf_div_2exp(low_bound, x, nbits+32);
// Sum the series sum_k=1^\infty a_k x^k
// It should equal sin(2pi/(1+x))
mpf_set_d(x, xf);
mpf_set_ui(sum, 0);
mpf_set(xn, x);
for (k=1; k<100000; k++)
{
topsin_series(a_k, k, prec);
mpf_mul(term, a_k, xn);
mpf_add(sum, sum, term);
// If the term is small enough, we are done.
mpf_abs(term, term);
if (mpf_cmp(term, low_bound) < 0) break;
mpf_mul(xn, xn, x);
}
// Now compute sin(2pi/(1+x))
mpf_add_ui(term, x, 1);
fp_two_pi(sino, prec);
mpf_div(term, sino, term);
fp_sine(sino, term, prec);
// the sum and the sine should be equal
mpf_sub(term, sino, sum);
double zero = mpf_get_d(term);
double lim = pow(10.0, -prec);
if (fabs(zero) > lim)
{
printf("Error: Expecting precision 1.0e-%d got %g at x=%f\n", prec, zero, xf);
fail = true;
}
mpf_clear(a_k);
mpf_clear(x);
mpf_clear(xn);
mpf_clear(term);
mpf_clear(sum);
mpf_clear(sino);
mpf_clear(low_bound);
return fail;
}
void
check_rand1 (int argc, char **argv)
{
mp_size_t size;
mp_exp_t exp;
int reps = 20000;
int i;
mpf_t x, y, y2;
mp_size_t bprec = 100;
mpf_t rerr, max_rerr, limit_rerr;
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_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, bprec);
#if VERBOSE
mpf_dump (limit_rerr);
#endif
mpf_init (rerr);
mpf_init_set_ui (max_rerr, 0);
mpf_init (x);
mpf_init (y);
mpf_init (y2);
for (i = 0; i < reps; i++)
{
size = urandom () % SIZE;
exp = urandom () % SIZE;
mpf_random2 (x, size, exp);
mpf_sqrt (y, x);
MPF_CHECK_FORMAT (y);
mpf_mul (y2, y, y);
mpf_reldiff (rerr, x, y2);
if (mpf_cmp (rerr, max_rerr) > 0)
{
mpf_set (max_rerr, rerr);
#if VERBOSE
mpf_dump (max_rerr);
#endif
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR after %d tests\n", i);
printf (" x = "); mpf_dump (x);
printf (" y = "); mpf_dump (y);
printf (" y2 = "); mpf_dump (y2);
printf (" rerr = "); mpf_dump (rerr);
printf (" limit_rerr = "); mpf_dump (limit_rerr);
printf ("in hex:\n");
mp_trace_base = 16;
mpf_trace (" x ", x);
mpf_trace (" y ", y);
mpf_trace (" y2 ", y2);
mpf_trace (" rerr ", rerr);
mpf_trace (" limit_rerr", limit_rerr);
abort ();
}
}
}
mpf_clear (limit_rerr);
mpf_clear (rerr);
mpf_clear (max_rerr);
mpf_clear (x);
mpf_clear (y);
mpf_clear (y2);
}
int
main (int argc, char **argv)
{
mp_size_t size;
mp_exp_t exp;
int reps = 20000;
int i;
mpf_t u, v, w, wref;
mp_size_t bprec = 100;
mpf_t rerr, max_rerr, limit_rerr;
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_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, bprec);
#if VERBOSE
mpf_dump (limit_rerr);
#endif
mpf_init (rerr);
mpf_init_set_ui (max_rerr, 0);
mpf_init (u);
mpf_init (v);
mpf_init (w);
mpf_init (wref);
for (i = 0; i < reps; i++)
{
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % SIZE;
mpf_random2 (u, size, exp);
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % SIZE;
mpf_random2 (v, size, exp);
mpf_add (w, u, v);
refmpf_add (wref, u, v);
mpf_reldiff (rerr, w, wref);
if (mpf_cmp (rerr, max_rerr) > 0)
{
mpf_set (max_rerr, rerr);
#if VERBOSE
mpf_dump (max_rerr);
#endif
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR after %d tests\n", i);
printf (" u = "); mpf_dump (u);
printf (" v = "); mpf_dump (v);
printf ("wref = "); mpf_dump (wref);
printf (" w = "); mpf_dump (w);
abort ();
}
}
}
mpf_clear (limit_rerr);
mpf_clear (rerr);
mpf_clear (max_rerr);
mpf_clear (u);
mpf_clear (v);
mpf_clear (w);
mpf_clear (wref);
tests_end ();
exit (0);
}
/* Test that there is no lost of accuracy when converting a mpfr_t number
into a mpf_t number (test with various precisions and exponents). */
static void
prec_test (void)
{
int px, py;
for (py = 3; py <= 136; py++)
{
mpfr_t y1, y2, y3;
mpfr_init2 (y1, py);
mpfr_init2 (y2, py);
mpfr_init2 (y3, py);
for (px = 32; px <= 160; px += 32)
{
mpf_t x1, x2, x3;
int e;
mpf_init (x1);
mpf_init (x2);
mpf_init (x3);
mpfr_set_ui_2exp (y1, 1, py - 1, MPFR_RNDN);
mpfr_get_f (x1, y1, MPFR_RNDN); /* exact (power of 2) */
mpf_set (x2, x1);
mpfr_set (y2, y1, MPFR_RNDN);
for (e = py - 2; e >= 0; e--)
{
int inex;
mpf_div_2exp (x2, x2, 1);
mpf_add (x1, x1, x2);
mpfr_div_2exp (y2, y2, 1, MPFR_RNDN);
inex = mpfr_add (y1, y1, y2, MPFR_RNDN);
MPFR_ASSERTN (inex == 0);
mpfr_set_f (y3, x1, MPFR_RNDN);
if (! mpfr_equal_p (y1, y3))
break;
inex = mpfr_get_f (x3, y3, MPFR_RNDN);
if (mpf_cmp (x1, x3) != 0)
{
printf ("Error in prec_test (px = %d, py = %d, e = %d)\n",
px, py, e);
printf ("x1 = ");
mpf_out_str (stdout, 16, 0, x1);
printf ("\nx2 = ");
mpf_out_str (stdout, 16, 0, x2);
printf ("\n");
exit (1);
}
if (inex != 0)
{
printf ("Error in prec_test (px = %d, py = %d, e = %d)\n",
px, py, e);
printf ("wrong ternary value got: %+d, expected: 0\n",
inex);
exit (1);
}
}
mpf_clear (x1);
mpf_clear (x2);
mpf_clear (x3);
}
mpfr_clear (y1);
mpfr_clear (y2);
mpfr_clear (y3);
}
}
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);
}
int
main (int argc, char **argv)
{
mpf_t x, y;
int reps = 20000;
int i;
mp_size_t bprec = 100;
mpf_t d, rerr, max_rerr, limit_rerr;
char *str;
mp_exp_t bexp;
long size, exp;
int base;
char buf[SIZE * GMP_LIMB_BITS + 5];
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_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, bprec);
#if VERBOSE
mpf_dump (limit_rerr);
#endif
mpf_init (rerr);
mpf_init_set_ui (max_rerr, 0);
mpf_init (x);
mpf_init (y);
mpf_init (d);
/* First test some specific values. */
mpf_set_str (y, "1.23456e1000", 0);
mpf_set_str (x, "1.23456e1000", 10);
if (mpf_cmp (x, y) != 0)
abort ();
mpf_set_str (x, "1.23456e+1000", 0);
if (mpf_cmp (x, y) != 0)
abort ();
mpf_set_str (x, "1.23456e+1000", 10);
if (mpf_cmp (x, y) != 0)
abort ();
/* Now test random values. */
for (i = 0; i < reps; i++)
{
if (i == 0)
{
/* exercise the special case in get_str for for x==0 */
mpf_set_ui (x, 0L);
base = 10;
}
else
{
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % EXPO;
mpf_random2 (x, size, exp);
base = urandom () % 61 + 2;
}
str = mpf_get_str (0, &bexp, base, 0, x);
if (str[0] == '-')
sprintf (buf, "-0.%s@%ld", str + 1, bexp);
else
sprintf (buf, "0.%s@%ld", str, bexp);
mpf_set_str_or_abort (y, buf, -base);
(*__gmp_free_func) (str, strlen (str) + 1);
mpf_reldiff (rerr, x, y);
if (mpf_cmp (rerr, max_rerr) > 0)
{
mpf_set (max_rerr, rerr);
#if VERBOSE
mpf_dump (max_rerr);
#endif
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR after %d tests\n", i);
printf ("base = %d\n", base);
printf (" x = ");
mpf_dump (x);
printf (" y = ");
mpf_dump (y);
abort ();
}
}
}
mpf_clear (limit_rerr);
mpf_clear (rerr);
mpf_clear (max_rerr);
mpf_clear (x);
mpf_clear (y);
mpf_clear (d);
tests_end ();
exit (0);
}
void
check_rand (int argc, char **argv)
{
mp_size_t size;
mp_exp_t exp;
int reps = 20000;
int i;
mpf_t u, v, w, wref;
mp_size_t bprec = 100;
mpf_t rerr, max_rerr, limit_rerr;
gmp_randstate_t rands;
if (argc > 1)
{
reps = strtol (argv[1], 0, 0);
if (argc > 2)
bprec = strtol (argv[2], 0, 0);
}
mpf_set_default_prec (bprec);
gmp_randinit_default(rands);
mpf_init_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, bprec);
#if VERBOSE
mpf_dump (limit_rerr);
#endif
mpf_init (rerr);
mpf_init_set_ui (max_rerr, 0);
mpf_init (u);
mpf_init (v);
mpf_init (w);
mpf_init (wref);
for (i = 0; i < reps; i++)
{
size = urandom (rands) % (2 * SIZE) - SIZE;
exp = urandom (rands) % SIZE;
mpf_rrandomb (u, rands, size, exp);
size = urandom (rands) % (2 * SIZE) - SIZE;
exp = urandom (rands) % SIZE;
mpf_rrandomb (v, rands, size, exp);
if ((urandom (rands) & 1) != 0)
mpf_add_ui (u, v, 1);
else if ((urandom (rands) & 1) != 0)
mpf_sub_ui (u, v, 1);
mpf_sub (w, u, v);
refmpf_sub (wref, u, v);
mpf_reldiff (rerr, w, wref);
if (mpf_cmp (rerr, max_rerr) > 0)
{
mpf_set (max_rerr, rerr);
#if VERBOSE
mpf_dump (max_rerr);
#endif
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR after %d tests\n", i);
printf (" u = ");
mpf_dump (u);
printf (" v = ");
mpf_dump (v);
printf ("wref = ");
mpf_dump (wref);
printf (" w = ");
mpf_dump (w);
abort ();
}
}
}
mpf_clear (limit_rerr);
mpf_clear (rerr);
mpf_clear (max_rerr);
mpf_clear (u);
mpf_clear (v);
mpf_clear (w);
mpf_clear (wref);
gmp_randclear(rands);
}
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);
}
/** @brief Tester program for EGlpNum_t structure and functions
* @return zero on success, non-zero otherwise
* @par Description:
* Perform various tests on EGlpNum_t and their functions
* */
int main (int argc,
char **argv)
{
/* local variables */
EGlpNum_t ntmp[4];
double dtmp[5];
char *strnum1,
*strnum2,
*strnum3;
int rval=0;
#ifdef HAVE_LIBGMP
int n_char = 0;
mpq_t qnum;
#endif
EGlpNumStart();
/* set signal and limits */
EGsigSet(rval,CLEANUP);
EGsetLimits(3600.0,4294967295UL);
#ifdef HAVE_LIBGMP
EGlpNumSetPrecision (128);
mpq_init (qnum);
#endif
EGlpNumInitVar (ntmp[0]);
EGlpNumInitVar (ntmp[1]);
EGlpNumInitVar (ntmp[2]);
EGlpNumInitVar (ntmp[3]);
/* the input should have at least two parameters, namelly the number where we
* will work on */
if (argc < 3)
{
fprintf (stderr,
"usage: %s num1 num2\n\tWhere num1 and num2 are numbers in"
" the number format (either a/b or regular doubles)\n", argv[0]);
exit (1);
}
/* we ask for two numbers and perform some basic operations and compare
* aganist double arithmetic */
#ifdef HAVE_LIBGMP
n_char = mpq_EGlpNumReadStrXc (qnum, argv[1]);
#endif
EGlpNumReadStr (ntmp[0], argv[1]);
EGlpNumReadStr (ntmp[1], argv[2]);
dtmp[0] = EGlpNumToLf (ntmp[0]);
dtmp[1] = EGlpNumToLf (ntmp[1]);
/* convert numbers */
strnum1 = EGlpNumGetStr (ntmp[0]);
strnum2 = EGlpNumGetStr (ntmp[1]);
fprintf (stderr, "You Input %s (%lg) and %s (%lg)\n", strnum1, dtmp[0],
strnum2, dtmp[1]);
#ifdef HAVE_LIBGMP
strnum3 = mpq_EGlpNumGetStr (qnum);
fprintf (stderr, "Your first number represented as exact rational is %s, "
"readed with %d chars\n", strnum3, n_char);
free (strnum3);
mpq_EGlpNumSet (qnum, dtmp[0]);
strnum3 = mpq_EGlpNumGetStr (qnum);
fprintf (stderr, "Your first number represented as continuous fraction "
"is %s, readed with %d chars\n", strnum3, n_char);
free (strnum3);
#endif
/* internal constants */
strnum3 = EGlpNumGetStr (oneLpNum);
fprintf (stderr, "1.0 = %s\n", strnum3);
EGfree (strnum3);
strnum3 = EGlpNumGetStr (zeroLpNum);
fprintf (stderr, "0.0 = %s\n", strnum3);
EGfree (strnum3);
strnum3 = EGlpNumGetStr (epsLpNum);
fprintf (stderr, "eps = %s\n", strnum3);
EGfree (strnum3);
strnum3 = EGlpNumGetStr (MaxLpNum);
fprintf (stderr, "Max = %s\n", strnum3);
EGfree (strnum3);
strnum3 = EGlpNumGetStr (MinLpNum);
fprintf (stderr, "Min = %s\n", strnum3);
EGfree (strnum3);
/* copying functions */
EGlpNumCopy (ntmp[2], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = %s (%lg)\n", strnum3, strnum1, dtmp[0]);
EGfree (strnum3);
EGlpNumCopyDiff (ntmp[2], ntmp[0], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = %s - %s (%lg)\n", strnum3, strnum1, strnum2,
dtmp[0] - dtmp[1]);
EGfree (strnum3);
EGlpNumCopyDiffRatio (ntmp[2], ntmp[0], ntmp[1], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = (%s - %s)/%s (%lg)\n", strnum3, strnum1, strnum2,
strnum1, (dtmp[0] - dtmp[1]) / dtmp[0]);
EGfree (strnum3);
EGlpNumCopySum (ntmp[2], ntmp[0], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = %s + %s (%lg)\n", strnum3, strnum1, strnum2,
dtmp[0] + dtmp[1]);
EGfree (strnum3);
EGlpNumCopySqrOver (ntmp[2], ntmp[1], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = %s^2/%s (%lg)\n", strnum3, strnum2, strnum1,
dtmp[1] * dtmp[1] / dtmp[0]);
EGfree (strnum3);
EGlpNumCopyAbs (ntmp[2], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = |%s| (%lg)\n", strnum3, strnum1, fabs (dtmp[0]));
EGfree (strnum3);
EGlpNumCopyNeg (ntmp[2], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = -1*%s (%lg)\n", strnum3, strnum1, -dtmp[0]);
EGfree (strnum3);
EGlpNumCopyFrac (ntmp[2], ntmp[1], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s = %s/%s (%lg)\n", strnum3, strnum2, strnum1,
dtmp[1] / dtmp[0]);
EGfree (strnum3);
/* add */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumAddTo (ntmp[2], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s + %s = %s (%lg)\n", strnum1, strnum2, strnum3,
dtmp[0] + dtmp[1]);
EGfree (strnum3);
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumAddUiTo (ntmp[2], 0xffU);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s + %u = %s (%lg)\n", strnum1, 0xffU, strnum3,
dtmp[0] + 0xffU);
EGfree (strnum3);
/* substract */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumSubTo (ntmp[2], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s - %s = %s (%lg)\n", strnum1, strnum2, strnum3,
dtmp[0] - dtmp[1]);
EGfree (strnum3);
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumSubUiTo (ntmp[2], 0xffU);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s - %u = %s (%lg)\n", strnum1, 0xffU, strnum3,
dtmp[0] - 0xffU);
EGfree (strnum3);
/* multiply */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumMultTo (ntmp[2], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s * %s = %s (%lg)\n", strnum1, strnum2, strnum3,
dtmp[0] * dtmp[1]);
EGfree (strnum3);
/* multiply unsigned */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumMultUiTo (ntmp[2], 13);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s * 13 = %s (%lg)\n", strnum1, strnum3, dtmp[0] * 13);
EGfree (strnum3);
/* inverse */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumInv (ntmp[2]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "1/%s = %s (%lg)\n", strnum1, strnum3, 1.0 / dtmp[0]);
EGfree (strnum3);
/* floor and ceil */
EGlpNumFloor (ntmp[2], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "floor(%s) = %s (%lg)\n", strnum1, strnum3, floor (dtmp[0]));
EGfree (strnum3);
EGlpNumCeil (ntmp[2], ntmp[0]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "ceil(%s) = %s (%lg)\n", strnum1, strnum3, ceil (dtmp[0]));
EGfree (strnum3);
/* negative and inner products */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumSign (ntmp[2]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "-(%s) = %s (%lg)\n", strnum1, strnum3, -dtmp[0]);
EGfree (strnum3);
EGlpNumOne (ntmp[2]);
EGlpNumAddInnProdTo (ntmp[2], ntmp[0], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "1.0 + %s*%s = %s (%lg)\n", strnum1, strnum2, strnum3,
1.0 + dtmp[1] * dtmp[0]);
EGfree (strnum3);
EGlpNumOne (ntmp[2]);
EGlpNumSubInnProdTo (ntmp[2], ntmp[0], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "1.0 - %s*%s = %s (%lg)\n", strnum1, strnum2, strnum3,
1.0 - dtmp[1] * dtmp[0]);
EGfree (strnum3);
/* divide */
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumDivTo (ntmp[2], ntmp[1]);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s / %s = %s (%lg)\n", strnum1, strnum2, strnum3,
dtmp[0] / dtmp[1]);
EGfree (strnum3);
EGlpNumCopy (ntmp[2], ntmp[0]);
EGlpNumDivUiTo (ntmp[2], 0xffU);
strnum3 = EGlpNumGetStr (ntmp[2]);
fprintf (stderr, "%s / %u = %s (%lg)\n", strnum1, 0xffU, strnum3,
dtmp[0] / 0xffU);
EGfree (strnum3);
EGfree (strnum1);
EGfree (strnum2);
#ifdef HAVE_LIBGMP
/* test transformation to rationals */
{
mpq_t n1, n2;
mpf_t f1, f2;
mpq_init (n1);
mpq_init (n2);
mpf_init (f1);
mpf_init (f2);
mpf_EGlpNumSet(f1,EGlpNumToLf(ntmp[0]));
mpf_EGlpNumSet(f2,EGlpNumToLf(ntmp[1]));
mpq_EGlpNumSet_mpf (n1, f1);
mpq_EGlpNumSet_mpf (n2, f2);
strnum1 = mpq_EGlpNumGetStr (n1);
strnum2 = mpq_EGlpNumGetStr (n2);
fprintf (stderr, "Your input in rational was:\n\t(%10.7lf) %s\n\t(%10.7lf)"
" %s\n", EGlpNumToLf (ntmp[0]), strnum1, EGlpNumToLf (ntmp[1]),
strnum2);
EGfree (strnum1);
EGfree (strnum2);
/* test natural exponentiation */
mpf_EGlpNumEpow (f1, -38.81624211135693732736499880);
mpf_set_ui (f2, (unsigned long)1);
mpf_div_2exp (f2, f2, (unsigned long)56);
strnum1 = mpf_EGlpNumGetStr (f1);
strnum2 = mpf_EGlpNumGetStr (f2);
fprintf (stderr, "2^-56 = %s ~ %s\n", strnum1, strnum2);
EGfree (strnum1);
EGfree (strnum2);
mpq_clear (n1);
mpq_clear (n2);
mpf_clear (f1);
mpf_clear (f2);
}
#endif
/* ending */
CLEANUP:
EGlpNumClearVar (ntmp[0]);
EGlpNumClearVar (ntmp[1]);
EGlpNumClearVar (ntmp[2]);
EGlpNumClearVar (ntmp[3]);
#ifdef HAVE_LIBGMP
mpq_clear (qnum);
#endif
EGlpNumClear();
return 0;
}
