void
check_rand (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_t rands;
mpf_t got, u;
unsigned long prec, v;
int i;
/* The nails code in mpf_mul_ui currently isn't exact, so suppress these
tests for now. */
if (BITS_PER_UI > GMP_NUMB_BITS)
return;
mpf_init (got);
mpf_init (u);
gmp_randinit_default(rands);
for (i = 0; i < 200; i++)
{
/* got precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (got, prec);
/* u precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (u, prec);
/* u, possibly negative */
mpf_rrandomb (u, rands, PREC(u), (mp_exp_t) 20);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (u, u);
/* v, 0 to BITS_PER_ULONG bits (inclusive) */
prec = gmp_urandomm_ui (rands, BITS_PER_ULONG+1);
v = gmp_urandomb_ui (rands, prec);
if ((i % 2) == 0)
{
/* separate */
mpf_mul_ui (got, u, v);
check_one ("separate", got, u, v);
}
else
{
/* overlap */
prec = refmpf_set_overlap (got, u);
mpf_mul_ui (got, got, v);
check_one ("overlap src==dst", got, u, v);
mpf_set_prec_raw (got, prec);
}
}
mpf_clear (got);
mpf_clear (u);
gmp_randclear(rands);
}
int
main (int argc, char **argv)
{
mp_ptr ap, bp, rp, refp;
gmp_randstate_ptr rands;
int test;
TMP_DECL;
TMP_MARK;
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_N);
bp = TMP_ALLOC_LIMBS (MAX_N);
rp = TMP_ALLOC_LIMBS (MAX_N + 2);
refp = TMP_ALLOC_LIMBS (MAX_N + 2);
for (test = 0; test < COUNT; test++)
{
mp_size_t an, bn, rn;
unsigned size_log;
size_log = 1 + gmp_urandomm_ui (rands, SIZE_LOG);
an = 1 + gmp_urandomm_ui(rands, 1L << size_log);
size_log = 1 + gmp_urandomm_ui (rands, SIZE_LOG);
bn = 1 + gmp_urandomm_ui(rands, 1L << size_log);
/* Make sure an >= bn */
if (an < bn)
MP_SIZE_T_SWAP (an, bn);
mpn_random2 (ap, an);
mpn_random2 (bp, bn);
refmpn_mulmid (refp, ap, an, bp, bn);
mpn_mulmid (rp, ap, an, bp, bn);
rn = an + 3 - bn;
if (mpn_cmp (refp, rp, rn))
{
printf ("ERROR in test %d, an = %d, bn = %d, rn = %d\n",
test, (int) an, (int) bn, (int) rn);
printf("a: "); mpn_dump (ap, an);
printf("b: "); mpn_dump (bp, bn);
printf("r: "); mpn_dump (rp, rn);
printf("ref: "); mpn_dump (refp, rn);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
void
check_rand (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_t rands;
unsigned long prec;
mpf_t got;
mpq_t q;
int i;
mpf_init (got);
mpq_init (q);
gmp_randinit_default(rands);
for (i = 0; i < 400; i++)
{
/* result precision */
prec = min_prec + gmp_urandomm_ui (rands, 20L);
refmpf_set_prec_limbs (got, prec);
/* num */
prec = gmp_urandomm_ui (rands, 20L * GMP_NUMB_BITS);
mpz_rrandomb (mpq_numref(q), rands, prec);
/* possibly negative num */
if (gmp_urandomb_ui (rands, 1L))
mpz_neg (mpq_numref(q), mpq_numref(q));
/* den, non-zero */
do {
prec = gmp_urandomm_ui (rands, 20L * GMP_NUMB_BITS);
mpz_rrandomb (mpq_denref(q), rands, prec);
} while (mpz_sgn (mpq_denref(q)) <= 0);
check_one (got, q);
}
mpf_clear (got);
mpq_clear (q);
gmp_randclear(rands);
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
int i;
unsigned a_bits;
unsigned b_bits;
mpz_t a;
mpz_t b;
tests_start ();
rands = RANDS;
mpz_init (a);
mpz_init (b);
for (i = 0; i < 300; i++)
{
mp_size_t asize;
a_bits = 1 + gmp_urandomm_ui (rands, 1000);
b_bits = 1 + gmp_urandomm_ui (rands, GMP_NUMB_BITS);
mpz_rrandomb (a, rands, a_bits);
mpz_rrandomb (b, rands, b_bits);
asize = SIZ(a);
if (!asize)
asize = 1;
if (mpz_sgn (b) == 0)
mpz_set_ui (b, 1);
check_one (PTR(a), asize, PTR(b)[0]);
}
mpz_clear (a);
mpz_clear (b);
tests_end ();
return 0;
}
/* Exercise calls mpf(x,x,x) */
void
check_reuse_three (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_ptr rands = RANDS;
unsigned long result_prec, input_prec, set_prec;
mpf_t got;
int i;
mpf_init (got);
for (i = 0; i < 8; i++)
{
result_prec = min_prec + gmp_urandomm_ui (rands, 15L);
input_prec = min_prec + gmp_urandomm_ui (rands, 15L);
set_prec = MAX (result_prec, input_prec);
refmpf_set_prec_limbs (got, set_prec);
/* input, non-zero, possibly negative */
PREC(got) = input_prec;
do {
mpf_random2 (got, input_prec, (mp_exp_t) 20);
} while (SIZ(got) == 0);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (got, got);
PREC(got) = result_prec;
mpf_div (got, got, got);
/* expect exactly 1.0 always */
ASSERT_ALWAYS (mpf_cmp_ui (got, 1L) == 0);
PREC(got) = set_prec;
}
mpf_clear (got);
}
template <class FT> void BKZReduction<FT>::rerandomize_block(int min_row, int max_row, int density)
{
if (max_row - min_row < 2)
return;
// 1. permute rows
size_t niter = 4 * (max_row - min_row); // some guestimate
for (size_t i = 0; i < niter; ++i)
{
size_t a = gmp_urandomm_ui(RandGen::get_gmp_state(), max_row - min_row - 1) + min_row;
size_t b = a;
while (b == a)
{
b = gmp_urandomm_ui(RandGen::get_gmp_state(), max_row - min_row - 1) + min_row;
}
m.move_row(b, a);
}
// 2. triangular transformation matrix with coefficients in -1,0,1
m.row_op_begin(min_row, max_row);
FT x;
for (long a = min_row; a < max_row - 2; ++a)
{
for (long i = 0; i < density; i++)
{
size_t b = gmp_urandomm_ui(RandGen::get_gmp_state(), max_row - (a + 1) - 1) + a + 1;
if (gmp_urandomm_ui(RandGen::get_gmp_state(), 2))
m.row_add(a, b);
else
m.row_sub(a, b);
}
}
m.row_op_end(min_row, max_row);
return;
}
static void
check_rand (void)
{
gmp_randstate_ptr rands = RANDS;
int i;
mpz_t z;
double got;
long got_exp;
unsigned long bits;
mpz_init (z);
for (i = 0; i < 200; i++)
{
bits = gmp_urandomm_ui (rands, 512L);
mpz_urandomb (z, rands, bits);
got = mpz_get_d_2exp (&got_exp, z);
if (mpz_sgn (z) == 0)
continue;
bits = mpz_sizeinbase (z, 2);
if (got < 0.5 || got >= 1.0)
{
printf ("mpz_get_d_2exp out of range, expect 0.5 <= got < 1.0\n");
mpz_trace (" z ", z);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
/* FIXME: If mpz_get_d_2exp rounds upwards we might have got_exp ==
bits+1, so leave this test disabled until we decide if that's what
should happen, or not. */
#if 0
if (got_exp != bits)
{
printf ("mpz_get_d_2exp wrong exponent\n", i);
mpz_trace (" z ", z);
d_trace (" bits ", bits);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
#endif
}
mpz_clear (z);
}
/* Expect numbers generated by rstate to obey the limit requested. */
void
check_one (const char *name, gmp_randstate_ptr rstate)
{
static const unsigned long n_table[] = {
1, 2, 3, 4, 5, 6, 7, 8,
123, 456, 789,
255, 256, 257,
1023, 1024, 1025,
32767, 32768, 32769,
ULONG_MAX/2-2, ULONG_MAX/2-1, ULONG_MAX/2, ULONG_MAX/2+1, ULONG_MAX/2+2,
ULONG_MAX-2, ULONG_MAX-1, ULONG_MAX,
};
unsigned long got, n;
int i, j;
for (i = 0; i < numberof (n_table); i++)
{
n = n_table[i];
for (j = 0; j < 5; j++)
{
got = gmp_urandomm_ui (rstate, n);
if (got >= n)
{
printf ("Return value out of range:\n");
printf (" algorithm: %s\n", name);
printf (" n: %#lx\n", n);
printf (" got: %#lx\n", got);
abort ();
}
}
}
}
void
check_rand (void)
{
unsigned long max_prec = 15;
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_ptr rands = RANDS;
unsigned long x, prec;
mpf_t r, s;
int i;
mpf_init (r);
mpf_init (s);
refmpf_set_prec_limbs (s, 2*max_prec+10);
for (i = 0; i < 50; i++)
{
/* input, a random non-zero ulong, exponentially distributed */
do {
x = gmp_urandomb_ui (rands,
gmp_urandomm_ui (rands, BITS_PER_ULONG) + 1);
} while (x == 0);
/* result precision */
prec = gmp_urandomm_ui (rands, max_prec-min_prec) + min_prec;
refmpf_set_prec_limbs (r, prec);
mpf_sqrt_ui (r, x);
MPF_CHECK_FORMAT (r);
/* Expect to prec limbs of result.
In the current implementation there's no stripping of low zero
limbs in mpf_sqrt_ui, not even on perfect squares, so size should
be exactly prec. */
if (SIZ(r) != prec)
{
printf ("mpf_sqrt_ui result not enough result limbs\n");
printf (" x=%lu\n", x);
printf (" want prec=%lu\n", prec);
mpf_trace (" r", r);
printf (" r size %ld\n", (long) SIZ(r));
printf (" r prec %ld\n", (long) PREC(r));
abort ();
}
/* Must have r^2 <= x, since r has been truncated. */
mpf_mul (s, r, r);
if (! (mpf_cmp_ui (s, x) <= 0))
{
printf ("mpf_sqrt_ui result too big\n");
printf (" x=%lu\n", x);
printf (" want prec=%lu\n", prec);
mpf_trace (" r", r);
mpf_trace (" s", s);
abort ();
}
/* Must have (r+ulp)^2 > x.
No overflow from refmpf_add_ulp since r is only prec limbs. */
refmpf_add_ulp (r);
mpf_mul (s, r, r);
if (! (mpf_cmp_ui (s, x) > 0))
{
printf ("mpf_sqrt_ui result too small\n");
printf (" x=%lu\n", x);
printf (" want prec=%lu\n", prec);
mpf_trace (" r+ulp", r);
mpf_trace (" s", s);
abort ();
}
}
mpf_clear (r);
mpf_clear (s);
}
void
mpz_errandomb (mpz_ptr rop, gmp_randstate_t rstate, unsigned long nbits)
{
mpz_rrandomb (rop, rstate, gmp_urandomm_ui (rstate, nbits));
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
mp_ptr ap, rp, pp, scratch;
int count = COUNT;
unsigned i;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_LIMBS);
rp = TMP_ALLOC_LIMBS (MAX_LIMBS);
pp = TMP_ALLOC_LIMBS (MAX_LIMBS);
scratch = TMP_ALLOC_LIMBS (3*MAX_LIMBS); /* For mpn_powlo */
for (i = 0; i < count; i++)
{
mp_size_t n;
mp_limb_t k;
int c;
n = 1 + gmp_urandomm_ui (rands, MAX_LIMBS);
if (i & 1)
mpn_random2 (ap, n);
else
mpn_random (ap, n);
ap[0] |= 1;
if (i < 100)
k = 3 + 2*i;
else
{
mpn_random (&k, 1);
if (k < 3)
k = 3;
else
k |= 1;
}
mpn_broot (rp, ap, n, k);
mpn_powlo (pp, rp, &k, 1, n, scratch);
MPN_CMP (c, ap, pp, n);
if (c != 0)
{
gmp_fprintf (stderr,
"mpn_broot returned bad result: %u limbs\n",
(unsigned) n);
gmp_fprintf (stderr, "k = %Mx\n", k);
gmp_fprintf (stderr, "a = %Nx\n", ap, n);
gmp_fprintf (stderr, "r = %Nx\n", rp, n);
gmp_fprintf (stderr, "r^n = %Nx\n", pp, n);
abort ();
}
}
TMP_FREE;
tests_end ();
return 0;
}
int
main (int argc, char **argv)
{
mp_ptr ap, bp, refp, pp, scratch;
int count = COUNT;
int test;
gmp_randstate_ptr rands;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
#define mpn_mullo_itch(n) (0)
ap = TMP_ALLOC_LIMBS (MAX_N);
bp = TMP_ALLOC_LIMBS (MAX_N);
refp = TMP_ALLOC_LIMBS (MAX_N * 2);
pp = 1+TMP_ALLOC_LIMBS (MAX_N + 2);
scratch
= 1+TMP_ALLOC_LIMBS (mpn_mullo_itch (MAX_N) + 2);
for (test = 0; test < count; test++)
{
unsigned size_min;
unsigned size_range;
mp_size_t n;
mp_size_t itch;
mp_limb_t p_before, p_after, s_before, s_after;
for (size_min = 1; (1L << size_min) < MIN_N; size_min++)
;
/* We generate an in the MIN_N <= n <= (1 << size_range). */
size_range = size_min
+ gmp_urandomm_ui (rands, SIZE_LOG + 1 - size_min);
n = MIN_N
+ gmp_urandomm_ui (rands, (1L << size_range) + 1 - MIN_N);
mpn_random2 (ap, n);
mpn_random2 (bp, n);
mpn_random2 (pp-1, n + 2);
p_before = pp[-1];
p_after = pp[n];
itch = mpn_mullo_itch (n);
ASSERT_ALWAYS (itch <= mpn_mullo_itch (MAX_N));
mpn_random2 (scratch-1, itch+2);
s_before = scratch[-1];
s_after = scratch[itch];
mpn_mullo_n (pp, ap, bp, n);
mpn_mul_n (refp, ap, bp, n);
if (pp[-1] != p_before || pp[n] != p_after
|| scratch[-1] != s_before || scratch[itch] != s_after
|| mpn_cmp (refp, pp, n) != 0)
{
printf ("ERROR in test %d, n = %d",
test, (int) n);
if (pp[-1] != p_before)
{
printf ("before pp:"); mpn_dump (pp -1, 1);
printf ("keep: "); mpn_dump (&p_before, 1);
}
if (pp[n] != p_after)
{
printf ("after pp:"); mpn_dump (pp + n, 1);
printf ("keep: "); mpn_dump (&p_after, 1);
}
if (scratch[-1] != s_before)
{
printf ("before scratch:"); mpn_dump (scratch-1, 1);
printf ("keep: "); mpn_dump (&s_before, 1);
}
if (scratch[itch] != s_after)
{
printf ("after scratch:"); mpn_dump (scratch + itch, 1);
printf ("keep: "); mpn_dump (&s_after, 1);
}
mpn_dump (ap, n);
mpn_dump (bp, n);
mpn_dump (pp, n);
mpn_dump (refp, n);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
int
main (int argc, char **argv)
{
mp_ptr ip, dp, scratch;
int count = COUNT;
int test;
gmp_randstate_ptr rands;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
dp = TMP_ALLOC_LIMBS (MAX_N);
ip = 1+TMP_ALLOC_LIMBS (MAX_N + 2);
scratch
= 1+TMP_ALLOC_LIMBS (mpn_invert_itch (MAX_N) + 2);
for (test = 0; test < count; test++)
{
unsigned size_min;
unsigned size_range;
mp_size_t n;
mp_size_t itch;
mp_limb_t i_before, i_after, s_before, s_after;
for (size_min = 1; (1L << size_min) < MIN_N; size_min++)
;
/* We generate an in the MIN_N <= n <= (1 << size_range). */
size_range = size_min
+ gmp_urandomm_ui (rands, SIZE_LOG + 1 - size_min);
n = MIN_N
+ gmp_urandomm_ui (rands, (1L << size_range) + 1 - MIN_N);
mpn_random2 (dp, n);
mpn_random2 (ip-1, n + 2);
i_before = ip[-1];
i_after = ip[n];
itch = mpn_invert_itch (n);
ASSERT_ALWAYS (itch <= mpn_invert_itch (MAX_N));
mpn_random2 (scratch-1, itch+2);
s_before = scratch[-1];
s_after = scratch[itch];
dp[n-1] |= GMP_NUMB_HIGHBIT;
mpn_invert (ip, dp, n, scratch);
if (ip[-1] != i_before || ip[n] != i_after
|| scratch[-1] != s_before || scratch[itch] != s_after
|| ! invert_valid(ip, dp, n))
{
printf ("ERROR in test %d, n = %d\n",
test, (int) n);
if (ip[-1] != i_before)
{
printf ("before ip:"); mpn_dump (ip -1, 1);
printf ("keep: "); mpn_dump (&i_before, 1);
}
if (ip[n] != i_after)
{
printf ("after ip:"); mpn_dump (ip + n, 1);
printf ("keep: "); mpn_dump (&i_after, 1);
}
if (scratch[-1] != s_before)
{
printf ("before scratch:"); mpn_dump (scratch-1, 1);
printf ("keep: "); mpn_dump (&s_before, 1);
}
if (scratch[itch] != s_after)
{
printf ("after scratch:"); mpn_dump (scratch + itch, 1);
printf ("keep: "); mpn_dump (&s_after, 1);
}
mpn_dump (dp, n);
mpn_dump (ip, n);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
void
check_rand2 (void)
{
unsigned long max_prec = 20;
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_ptr rands = RANDS;
unsigned long x_prec, r_prec;
mpf_t x, r, s;
int i;
mpf_init (x);
mpf_init (r);
mpf_init (s);
refmpf_set_prec_limbs (s, 2*max_prec+10);
for (i = 0; i < 500; i++)
{
/* input precision */
x_prec = gmp_urandomm_ui (rands, max_prec-min_prec) + min_prec;
refmpf_set_prec_limbs (x, x_prec);
/* result precision */
r_prec = gmp_urandomm_ui (rands, max_prec-min_prec) + min_prec;
refmpf_set_prec_limbs (r, r_prec);
mpf_random2 (x, x_prec, 1000);
mpf_sqrt (r, x);
MPF_CHECK_FORMAT (r);
/* Expect to prec limbs of result.
In the current implementation there's no stripping of low zero
limbs in mpf_sqrt, so size should be exactly prec. */
if (SIZ(r) != r_prec)
{
printf ("mpf_sqrt wrong number of result limbs\n");
mpf_trace (" x", x);
mpf_trace (" r", r);
printf (" r_prec=%lu\n", r_prec);
printf (" SIZ(r) %ld\n", (long) SIZ(r));
printf (" PREC(r) %ld\n", (long) PREC(r));
abort ();
}
/* Must have r^2 <= x, since r has been truncated. */
mpf_mul (s, r, r);
if (! (mpf_cmp (s, x) <= 0))
{
printf ("mpf_sqrt result too big\n");
mpf_trace (" x", x);
printf (" r_prec=%lu\n", r_prec);
mpf_trace (" r", r);
mpf_trace (" s", s);
abort ();
}
/* Must have (r+ulp)^2 > x, or else r is too small. */
refmpf_add_ulp (r);
mpf_mul (s, r, r);
if (! (mpf_cmp (s, x) > 0))
{
printf ("mpf_sqrt result too small\n");
mpf_trace (" x", x);
printf (" r_prec=%lu\n", r_prec);
mpf_trace (" r+ulp", r);
mpf_trace (" s", s);
abort ();
}
}
mpf_clear (x);
mpf_clear (r);
mpf_clear (s);
}
void
check_rand (void)
{
gmp_randstate_t rands;
int rep, i;
unsigned long mant_bits;
long exp, exp_min, exp_max;
double got, want, d;
mp_size_t nalloc, nsize, sign;
mp_limb_t nhigh_mask;
mp_ptr np;
gmp_randinit_default(rands);
mant_bits = tests_dbl_mant_bits ();
if (mant_bits == 0)
return;
/* Allow for vax D format with exponent 127 to -128 only.
FIXME: Do something to probe for a valid exponent range. */
exp_min = -100 - mant_bits;
exp_max = 100 - mant_bits;
/* space for mant_bits */
nalloc = BITS_TO_LIMBS (mant_bits);
np = refmpn_malloc_limbs (nalloc);
nhigh_mask = MP_LIMB_T_MAX
>> (GMP_NAIL_BITS + nalloc * GMP_NUMB_BITS - mant_bits);
for (rep = 0; rep < 200; rep++)
{
/* random exp_min to exp_max, inclusive */
exp = exp_min + (long) gmp_urandomm_ui (rands, exp_max - exp_min + 1);
/* mant_bits worth of random at np */
if (rep & 1)
mpn_randomb (np, rands, nalloc);
else
mpn_rrandom (np, rands,nalloc);
nsize = nalloc;
np[nsize-1] &= nhigh_mask;
MPN_NORMALIZE (np, nsize);
if (nsize == 0)
continue;
sign = (mp_size_t) gmp_urandomb_ui (rands, 1L) - 1;
/* want = {np,nsize}, converting one bit at a time */
want = 0.0;
for (i = 0, d = 1.0; i < mant_bits; i++, d *= 2.0)
if (np[i/GMP_NUMB_BITS] & (CNST_LIMB(1) << (i%GMP_NUMB_BITS)))
want += d;
if (sign < 0)
want = -want;
/* want = want * 2^exp */
for (i = 0; i < exp; i++)
want *= 2.0;
for (i = 0; i > exp; i--)
want *= 0.5;
got = mpn_get_d (np, nsize, sign, exp);
if (got != want)
{
printf ("mpn_get_d wrong on random data\n");
printf (" sign %ld\n", (long) sign);
mpn_trace (" n ", np, nsize);
printf (" nsize %ld\n", (long) nsize);
printf (" exp %ld\n", exp);
d_trace (" want ", want);
d_trace (" got ", got);
abort();
}
}
free (np);
gmp_randclear(rands);
}
void
check_rand (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_ptr rands = RANDS;
unsigned long prec;
mpf_t got, u, v;
int i;
mpf_init (got);
mpf_init (u);
mpf_init (v);
/* separate */
for (i = 0; i < 100; i++)
{
/* got precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (got, prec);
/* u */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (u, prec);
do {
mpf_random2 (u, PREC(u), (mp_exp_t) 20);
} while (SIZ(u) == 0);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (u, u);
/* v */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (v, prec);
do {
mpf_random2 (v, PREC(v), (mp_exp_t) 20);
} while (SIZ(v) == 0);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (v, v);
switch (i % 3) {
case 0:
mpf_div (got, u, v);
check_one ("separate", got, u, v);
break;
case 1:
prec = refmpf_set_overlap (got, u);
mpf_div (got, got, v);
check_one ("dst == u", got, u, v);
mpf_set_prec_raw (got, prec);
break;
case 2:
prec = refmpf_set_overlap (got, v);
mpf_div (got, u, got);
check_one ("dst == v", got, u, v);
mpf_set_prec_raw (got, prec);
break;
}
}
mpf_clear (got);
mpf_clear (u);
mpf_clear (v);
}
static void
check_set_str (mpfr_exp_t exp_max)
{
mpc_t expected;
mpc_t got;
char *str;
mpfr_prec_t prec;
mpfr_exp_t exp_min;
int base;
mpc_init2 (expected, 1024);
mpc_init2 (got, 1024);
exp_min = mpfr_get_emin ();
if (exp_max <= 0)
exp_max = mpfr_get_emax ();
else if (exp_max > mpfr_get_emax ())
exp_max = mpfr_get_emax();
if (-exp_max > exp_min)
exp_min = - exp_max;
for (prec = 2; prec < 1024; prec += 7)
{
mpc_set_prec (got, prec);
mpc_set_prec (expected, prec);
base = 2 + (int) gmp_urandomm_ui (rands, 35);
/* uses external variable rands from random.c */
mpfr_set_nan (MPC_RE (expected));
mpfr_set_inf (MPC_IM (expected), prec % 2 - 1);
str = mpc_get_str (base, 0, expected, MPC_RNDNN);
if (mpfr_nan_p (MPC_RE (got)) == 0
|| mpfr_cmp (MPC_IM (got), MPC_IM (expected)) != 0)
{
printf ("Error: mpc_set_str o mpc_get_str != Id\n"
"in base %u with str=\"%s\"\n", base, str);
MPC_OUT (expected);
printf (" ");
MPC_OUT (got);
exit (1);
}
mpc_free_str (str);
test_default_random (expected, exp_min, exp_max, 128, 25);
str = mpc_get_str (base, 0, expected, MPC_RNDNN);
if (mpc_set_str (got, str, base, MPC_RNDNN) == -1
|| mpc_cmp (got, expected) != 0)
{
printf ("Error: mpc_set_str o mpc_get_str != Id\n"
"in base %u with str=\"%s\"\n", base, str);
MPC_OUT (expected);
printf (" ");
MPC_OUT (got);
exit (1);
}
mpc_free_str (str);
}
#ifdef HAVE_SETLOCALE
{
/* Check with ',' as a decimal point */
char *old_locale;
old_locale = setlocale (LC_ALL, "de_DE");
if (old_locale != NULL)
{
str = mpc_get_str (10, 0, expected, MPC_RNDNN);
if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
|| mpc_cmp (got, expected) != 0)
{
printf ("Error: mpc_set_str o mpc_get_str != Id\n"
"with str=\"%s\"\n", str);
MPC_OUT (expected);
printf (" ");
MPC_OUT (got);
exit (1);
}
mpc_free_str (str);
setlocale (LC_ALL, old_locale);
}
}
#endif /* HAVE_SETLOCALE */
/* the real part has a zero exponent in base ten (fixed in r439) */
mpc_set_prec (expected, 37);
mpc_set_prec (got, 37);
mpc_set_str (expected, "921FC04EDp-35 ", 16, GMP_RNDN);
str = mpc_get_str (10, 0, expected, MPC_RNDNN);
if (mpc_set_str (got, str, 10, MPC_RNDNN) == -1
|| mpc_cmp (got, expected) != 0)
{
printf ("Error: mpc_set_str o mpc_get_str != Id\n"
"with str=\"%s\"\n", str);
MPC_OUT (expected);
printf (" ");
MPC_OUT (got);
exit (1);
}
mpc_free_str (str);
str = mpc_get_str (1, 0, expected, MPC_RNDNN);
if (str != NULL)
{
printf ("Error: mpc_get_str with base==1 should fail\n");
exit (1);
}
mpc_clear (expected);
mpc_clear (got);
}
