/* 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; }