void
one (int i, mpz_t multiplicand, mpz_t multiplier)
{
mpz_t product, ref_product;
mpz_init (product);
mpz_init (ref_product);
/* Test plain multiplication comparing results against reference code. */
mpz_mul (product, multiplier, multiplicand);
refmpz_mul (ref_product, multiplier, multiplicand);
if (mpz_cmp (product, ref_product))
dump_abort (i, "incorrect plain product",
multiplier, multiplicand, product, ref_product);
/* Test squaring, comparing results against plain multiplication */
mpz_mul (product, multiplier, multiplier);
mpz_set (multiplicand, multiplier);
mpz_mul (ref_product, multiplier, multiplicand);
if (mpz_cmp (product, ref_product))
dump_abort (i, "incorrect square product",
multiplier, multiplier, product, ref_product);
mpz_clear (product);
mpz_clear (ref_product);
}
int
main (int argc, char **argv)
{
mpz_t dividend, divisor;
mpz_t quotient, remainder;
mpz_t quotient2, remainder2;
mpz_t temp;
mp_size_t dividend_size, divisor_size;
int i;
int reps = 1000;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
TESTS_REPS (reps, argv, argc);
rands = RANDS;
mpz_init (bs);
mpz_init (dividend);
mpz_init (divisor);
mpz_init (quotient);
mpz_init (remainder);
mpz_init (quotient2);
mpz_init (remainder2);
mpz_init (temp);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 18 + 2; /* 0..524288 bit operands */
do
{
mpz_urandomb (bs, rands, size_range);
divisor_size = mpz_get_ui (bs);
mpz_rrandomb (divisor, rands, divisor_size);
}
while (mpz_sgn (divisor) == 0);
mpz_urandomb (bs, rands, size_range);
dividend_size = mpz_get_ui (bs) + divisor_size;
mpz_rrandomb (dividend, rands, dividend_size);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (dividend, dividend);
if ((bsi & 2) != 0)
mpz_neg (divisor, divisor);
/* printf ("%ld %ld\n", SIZ (dividend), SIZ (divisor)); */
mpz_tdiv_qr (quotient, remainder, dividend, divisor);
mpz_tdiv_q (quotient2, dividend, divisor);
mpz_tdiv_r (remainder2, dividend, divisor);
/* First determine that the quotients and remainders computed
with different functions are equal. */
if (mpz_cmp (quotient, quotient2) != 0)
dump_abort (dividend, divisor);
if (mpz_cmp (remainder, remainder2) != 0)
dump_abort (dividend, divisor);
/* Check if the sign of the quotient is correct. */
if (mpz_cmp_ui (quotient, 0) != 0)
if ((mpz_cmp_ui (quotient, 0) < 0)
!= ((mpz_cmp_ui (dividend, 0) ^ mpz_cmp_ui (divisor, 0)) < 0))
dump_abort (dividend, divisor);
/* Check if the remainder has the same sign as the dividend
(quotient rounded towards 0). */
if (mpz_cmp_ui (remainder, 0) != 0)
if ((mpz_cmp_ui (remainder, 0) < 0) != (mpz_cmp_ui (dividend, 0) < 0))
dump_abort (dividend, divisor);
mpz_mul (temp, quotient, divisor);
mpz_add (temp, temp, remainder);
if (mpz_cmp (temp, dividend) != 0)
dump_abort (dividend, divisor);
mpz_abs (temp, divisor);
mpz_abs (remainder, remainder);
if (mpz_cmp (remainder, temp) >= 0)
dump_abort (dividend, divisor);
}
mpz_clear (bs);
mpz_clear (dividend);
mpz_clear (divisor);
mpz_clear (quotient);
mpz_clear (remainder);
mpz_clear (quotient2);
mpz_clear (remainder2);
mpz_clear (temp);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t dividend;
mpz_t quotient, remainder;
mpz_t quotient2, remainder2;
mpz_t temp;
mp_size_t dividend_size;
unsigned long divisor;
int i;
int reps = 10000;
gmp_randstate_t rands;
mpz_t bs;
unsigned long bsi, size_range;
unsigned long r_rq, r_q, r_r, r;
tests_start ();
gmp_randinit_default(rands);
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (dividend);
mpz_init (quotient);
mpz_init (remainder);
mpz_init (quotient2);
mpz_init (remainder2);
mpz_init (temp);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 10 + 2; /* 0..2047 bit operands */
do
{
mpz_rrandomb (bs, rands, 64);
divisor = mpz_get_ui (bs);
}
while (divisor == 0);
mpz_urandomb (bs, rands, size_range);
dividend_size = mpz_get_ui (bs);
mpz_rrandomb (dividend, rands, dividend_size);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (dividend, dividend);
/* printf ("%ld\n", SIZ (dividend)); */
r_rq = mpz_cdiv_qr_ui (quotient, remainder, dividend, divisor);
r_q = mpz_cdiv_q_ui (quotient2, dividend, divisor);
r_r = mpz_cdiv_r_ui (remainder2, dividend, divisor);
r = mpz_cdiv_ui (dividend, divisor);
/* First determine that the quotients and remainders computed
with different functions are equal. */
if (mpz_cmp (quotient, quotient2) != 0)
dump_abort ("quotients from mpz_cdiv_qr_ui and mpz_cdiv_q_ui differ",
dividend, divisor);
if (mpz_cmp (remainder, remainder2) != 0)
dump_abort ("remainders from mpz_cdiv_qr_ui and mpz_cdiv_r_ui differ",
dividend, divisor);
/* Check if the sign of the quotient is correct. */
if (mpz_cmp_ui (quotient, 0) != 0)
if ((mpz_cmp_ui (quotient, 0) < 0)
!= (mpz_cmp_ui (dividend, 0) < 0))
dump_abort ("quotient sign wrong", dividend, divisor);
/* Check if the remainder has the opposite sign as the (positive) divisor
(quotient rounded towards minus infinity). */
if (mpz_cmp_ui (remainder, 0) != 0)
if (mpz_cmp_ui (remainder, 0) > 0)
dump_abort ("remainder sign wrong", dividend, divisor);
mpz_mul_ui (temp, quotient, divisor);
mpz_add (temp, temp, remainder);
if (mpz_cmp (temp, dividend) != 0)
dump_abort ("n mod d != n - [n/d]*d", dividend, divisor);
mpz_abs (remainder, remainder);
if (mpz_cmp_ui (remainder, divisor) >= 0)
dump_abort ("remainder greater than divisor", dividend, divisor);
if (mpz_cmp_ui (remainder, r_rq) != 0)
dump_abort ("remainder returned from mpz_cdiv_qr_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r_q) != 0)
dump_abort ("remainder returned from mpz_cdiv_q_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r_r) != 0)
dump_abort ("remainder returned from mpz_cdiv_r_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r) != 0)
dump_abort ("remainder returned from mpz_cdiv_ui is wrong",
dividend, divisor);
}
mpz_clear (bs);
mpz_clear (dividend);
mpz_clear (quotient);
mpz_clear (remainder);
mpz_clear (quotient2);
mpz_clear (remainder2);
mpz_clear (temp);
gmp_randclear(rands);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, r1, r2;
mp_size_t op1n, op2n;
unsigned long int op2long;
int i;
int reps = 100000;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (op1);
mpz_init (op2);
mpz_init (r1);
mpz_init (r2);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 10 + 2;
mpz_urandomb (bs, rands, size_range);
op1n = mpz_get_ui (bs);
mpz_rrandomb (op1, rands, op1n);
mpz_urandomb (bs, rands, size_range);
op2n = mpz_get_ui (bs);
mpz_rrandomb (op2, rands, op2n);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
/* printf ("%ld %ld\n", SIZ (multiplier), SIZ (multiplicand)); */
mpz_add (r1, op1, op2);
mpz_sub (r2, r1, op2);
if (mpz_cmp (r2, op1) != 0)
dump_abort (i, "mpz_add or mpz_sub incorrect", op1, op2);
if (mpz_fits_ulong_p (op2))
{
op2long = mpz_get_ui (op2);
mpz_add_ui (r1, op1, op2long);
mpz_sub_ui (r2, r1, op2long);
if (mpz_cmp (r2, op1) != 0)
dump_abort (i, "mpz_add_ui or mpz_sub_ui incorrect", op1, op2);
mpz_ui_sub (r1, op2long, op1);
mpz_sub_ui (r2, op1, op2long);
mpz_neg (r2, r2);
if (mpz_cmp (r1, r2) != 0)
dump_abort (i, "mpz_add_ui or mpz_ui_sub incorrect", op1, op2);
}
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (r1);
mpz_clear (r2);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t x2;
mpz_t x, rem;
mpz_t temp, temp2;
mp_size_t x2_size;
int i;
int reps = 1000;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long size_range;
tests_start ();
TESTS_REPS (reps, argv, argc);
rands = RANDS;
mpz_init (bs);
mpz_init (x2);
mpz_init (x);
mpz_init (rem);
mpz_init (temp);
mpz_init (temp2);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 17 + 2; /* 0..262144 bit operands */
mpz_urandomb (bs, rands, size_range);
x2_size = mpz_get_ui (bs);
mpz_rrandomb (x2, rands, x2_size);
/* printf ("%ld\n", SIZ (x2)); */
mpz_sqrtrem (x, rem, x2);
MPZ_CHECK_FORMAT (x);
MPZ_CHECK_FORMAT (rem);
mpz_mul (temp, x, x);
/* Is square of result > argument? */
if (mpz_cmp (temp, x2) > 0)
dump_abort (x2, x, rem);
mpz_add_ui (temp2, x, 1);
mpz_mul (temp2, temp2, temp2);
/* Is square of (result + 1) <= argument? */
if (mpz_cmp (temp2, x2) <= 0)
dump_abort (x2, x, rem);
mpz_add (temp2, temp, rem);
/* Is the remainder wrong? */
if (mpz_cmp (x2, temp2) != 0)
dump_abort (x2, x, rem);
}
mpz_clear (bs);
mpz_clear (x2);
mpz_clear (x);
mpz_clear (rem);
mpz_clear (temp);
mpz_clear (temp2);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
int i;
int pass, reps = 10000;
mpf_t in1, in2, out1;
unsigned long int in1i, in2i;
mpf_t res1, res2, res3;
mp_size_t bprec = 100;
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 (in1);
mpf_init (in2);
mpf_init (out1);
mpf_init (res1);
mpf_init (res2);
mpf_init (res3);
for (pass = 1; pass <= reps; pass++)
{
mpf_random2 (in1, urandom () % SIZE - SIZE/2, urandom () % EXPO);
mpf_random2 (in2, urandom () % SIZE - SIZE/2, urandom () % EXPO);
for (i = 0; i < sizeof (dss_funcs) / sizeof (dss_func); i++)
{
/* Don't divide by 0. */
if (i == 0 && mpf_cmp_ui (in2, 0) == 0)
continue;
(dss_funcs[i]) (res1, in1, in2);
mpf_set (out1, in1);
(dss_funcs[i]) (out1, out1, in2);
mpf_set (res2, out1);
mpf_set (out1, in2);
(dss_funcs[i]) (out1, in1, out1);
mpf_set (res3, out1);
if (mpf_cmp (res1, res2) != 0)
dump_abort (dss_func_names[i], res1, res2);
if (mpf_cmp (res1, res3) != 0)
dump_abort (dss_func_names[i], res1, res3);
}
in2i = urandom ();
for (i = 0; i < sizeof (dsi_funcs) / sizeof (dsi_func); i++)
{
/* Don't divide by 0. */
if (strcmp (dsi_func_names[i], "mpf_div_ui") == 0 && in2i == 0)
continue;
(dsi_funcs[i]) (res1, in1, in2i);
mpf_set (out1, in1);
(dsi_funcs[i]) (out1, out1, in2i);
mpf_set (res2, out1);
if (mpf_cmp (res1, res2) != 0)
dump_abort (dsi_func_names[i], res1, res2);
}
in1i = urandom ();
for (i = 0; i < sizeof (dis_funcs) / sizeof (dis_func); i++)
{
/* Don't divide by 0. */
if (strcmp (dis_func_names[i], "mpf_ui_div") == 0
&& mpf_cmp_ui (in2, 0) == 0)
continue;
(dis_funcs[i]) (res1, in1i, in2);
mpf_set (out1, in2);
(dis_funcs[i]) (out1, in1i, out1);
mpf_set (res2, out1);
if (mpf_cmp (res1, res2) != 0)
dump_abort (dis_func_names[i], res1, res2);
}
}
mpf_clear (in1);
mpf_clear (in2);
mpf_clear (out1);
mpf_clear (res1);
mpf_clear (res2);
mpf_clear (res3);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t x2;
mpz_t x, rem;
mpz_t temp, temp2;
mp_size_t x2_size;
int i;
int reps = 20000;
gmp_randstate_t rands;
mpz_t bs;
unsigned long size_range;
tests_start ();
gmp_randinit_default(rands);
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (x2);
mpz_init (x);
mpz_init (rem);
mpz_init (temp);
mpz_init (temp2);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 12 + 2; /* 0..8191 bit operands */
mpz_urandomb (bs, rands, size_range);
x2_size = mpz_get_ui (bs);
mpz_rrandomb (x2, rands, x2_size);
/* printf ("%ld\n", SIZ (x2)); */
mpz_sqrtrem (x, rem, x2);
mpz_mul (temp, x, x);
/* Is square of result > argument? */
if (mpz_cmp (temp, x2) > 0)
dump_abort (x2, x, rem);
mpz_add_ui (temp2, x, 1);
mpz_mul (temp2, temp2, temp2);
/* Is square of (result + 1) <= argument? */
if (mpz_cmp (temp2, x2) <= 0)
dump_abort (x2, x, rem);
mpz_add (temp2, temp, rem);
/* Is the remainder wrong? */
if (mpz_cmp (x2, temp2) != 0)
dump_abort (x2, x, rem);
}
mpz_clear (bs);
mpz_clear (x2);
mpz_clear (x);
mpz_clear (rem);
mpz_clear (temp);
mpz_clear (temp2);
gmp_randclear(rands);
tests_end ();
exit (0);
}
void
check_random (long reps)
{
unsigned long test;
gmp_randstate_ptr rands = RANDS;
mpf_t a, b, x;
mpz_t ds;
int hibits, lshift1, lshift2;
int xtra;
#define HIBITS 10
#define LSHIFT1 10
#define LSHIFT2 10
mpf_set_default_prec ((1 << HIBITS) + (1 << LSHIFT1) + (1 << LSHIFT2));
mpz_init (ds);
mpf_inits (a, b, x, NULL);
for (test = 0; test < reps; test++)
{
mpz_urandomb (ds, rands, HIBITS);
hibits = mpz_get_ui (ds) + 1;
mpz_urandomb (ds, rands, hibits);
mpz_setbit (ds, hibits - 1); /* make sure msb is set */
mpf_set_z (a, ds);
mpf_set_z (b, ds);
mpz_urandomb (ds, rands, LSHIFT1);
lshift1 = mpz_get_ui (ds);
mpf_mul_2exp (a, a, lshift1 + 1);
mpf_mul_2exp (b, b, lshift1 + 1);
mpf_add_ui (a, a, 1); /* make a one-bit difference */
mpz_urandomb (ds, rands, LSHIFT2);
lshift2 = mpz_get_ui (ds);
mpf_mul_2exp (a, a, lshift2);
mpf_mul_2exp (b, b, lshift2);
mpz_urandomb (ds, rands, lshift2);
mpf_set_z (x, ds);
mpf_add (a, a, x);
mpf_add (b, b, x);
insert_random_low_zero_limbs (a, rands);
insert_random_low_zero_limbs (b, rands);
if (mpf_eq (a, b, lshift1 + hibits) == 0 ||
mpf_eq (b, a, lshift1 + hibits) == 0)
{
dump_abort (a, b, lshift1 + hibits, lshift1, lshift2, hibits, 1, test);
}
for (xtra = 1; xtra < 100; xtra++)
if (mpf_eq (a, b, lshift1 + hibits + xtra) != 0 ||
mpf_eq (b, a, lshift1 + hibits + xtra) != 0)
{
dump_abort (a, b, lshift1 + hibits + xtra, lshift1, lshift2, hibits, 0, test);
}
}
mpf_clears (a, b, x, NULL);
mpz_clear (ds);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, x;
mpz_t gcd, gcd2, s, t;
mpz_t temp1, temp2;
mp_size_t op1_size, op2_size, x_size;
int i;
int reps = 2000;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (op1);
mpz_init (op2);
mpz_init (x);
mpz_init (gcd);
mpz_init (gcd2);
mpz_init (temp1);
mpz_init (temp2);
mpz_init (s);
mpz_init (t);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 12 + 2; /* 0..8191 bit operands */
mpz_urandomb (bs, rands, size_range);
op1_size = mpz_get_ui (bs);
mpz_rrandomb (op1, rands, op1_size);
mpz_urandomb (bs, rands, size_range);
op2_size = mpz_get_ui (bs);
mpz_rrandomb (op2, rands, op2_size);
mpz_urandomb (bs, rands, size_range);
x_size = mpz_get_ui (bs);
mpz_rrandomb (x, rands, x_size);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
/* printf ("%ld %ld\n", SIZ (op1), SIZ (op2)); */
mpz_mul (op1, op1, x);
mpz_mul (op2, op2, x);
mpz_gcd (gcd, op1, op2);
/* We know GCD will be at least X, since we multiplied both operands
with it. */
if (mpz_cmp (gcd, x) < 0 && mpz_sgn (op1) != 0 && mpz_sgn (op2) != 0)
dump_abort (i, op1, op2);
if (mpz_fits_ulong_p (op2))
{
mpz_gcd_ui (gcd2, op1, mpz_get_ui (op2));
if (mpz_cmp (gcd, gcd2))
dump_abort (i, op1, op2);
}
mpz_gcdext (gcd2, s, t, op1, op2);
if (mpz_cmp (gcd, gcd2))
dump_abort (i, op1, op2);
mpz_gcdext (gcd2, s, NULL, op1, op2);
if (mpz_cmp (gcd, gcd2))
dump_abort (i, op1, op2);
mpz_mul (temp1, s, op1);
mpz_mul (temp2, t, op2);
mpz_add (gcd2, temp1, temp2);
if (mpz_cmp (gcd, gcd2))
dump_abort (i, op1, op2);
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (x);
mpz_clear (gcd);
mpz_clear (gcd2);
mpz_clear (temp1);
mpz_clear (temp2);
mpz_clear (s);
mpz_clear (t);
tests_end ();
exit (0);
}
