int
main (int argc, char *argv[])
{
unsigned long n, m;
unsigned long limit = 2222;
mpz_t df[2], f, r;
tests_start ();
if (argc > 1 && argv[1][0] == 'x')
limit = ULONG_MAX;
else if (argc > 1)
limit = atoi (argv[1]);
/* for small limb testing */
limit = MIN (limit, MP_LIMB_T_MAX);
mpz_init_set_ui (df[0], 1); /* 0!! = 1 */
mpz_init_set_ui (df[1], 1); /* -1!! = 1 */
mpz_init_set_ui (f, 1); /* 0! = 1 */
mpz_init (r);
for (n = 0, m = 0; n < limit; n++)
{
mpz_fac_ui (r, n);
MPZ_CHECK_FORMAT (r);
if (mpz_cmp (f, r) != 0)
{
printf ("mpz_fac_ui(%lu) wrong\n", n);
printf (" got "); mpz_out_str (stdout, 10, r); printf("\n");
printf (" want "); mpz_out_str (stdout, 10, f); printf("\n");
abort ();
}
mpz_2fac_ui (r, n);
MPZ_CHECK_FORMAT (r);
if (mpz_cmp (df[m], r) != 0)
{
printf ("mpz_2fac_ui(%lu) wrong\n", n);
printf (" got "); mpz_out_str (stdout, 10, r); printf("\n");
printf (" want "); mpz_out_str (stdout, 10, df[m]); printf("\n");
abort ();
}
m ^= 1;
mpz_mul_ui (df[m], df[m], n+1); /* (n+1)!! = (n-1)!! * (n+1) */
mpz_mul_ui (f, f, n+1); /* (n+1)! = n! * (n+1) */
}
n = 1048573; /* a prime */
if (n > MP_LIMB_T_MAX)
n = 65521; /* a smaller prime :-) */
mpz_fac_ui (f, n - 1);
m = mpz_fdiv_ui (f, n);
if ( m != n - 1)
{
printf ("mpz_fac_ui(%lu) wrong\n", n - 1);
printf (" Wilson's theorem not verified: got %lu, expected %lu.\n",m ,n - 1);
abort ();
}
mpz_clear (df[0]);
mpz_clear (df[1]);
mpz_clear (f);
mpz_clear (r);
tests_end ();
exit (0);
}
int
main (void)
{
gmp_randstate_t rands;
int j, n;
mp_limb_t cp1[1000], cp2[1000], mp[1000], tp1[1000], tp2[1000], inv;
tests_start ();
gmp_randinit_default (rands);
for (n = 1; n < 100; n++)
{
for (j = 1; j < 100; j++)
{
mpn_randomb (mp, rands, n);
mp[0] |= 1;
modlimb_invert (inv, mp[0]);
inv = -inv;
mpn_randomb (tp1, rands, 2 * n);
MPN_COPY (tp2, tp1, 2 * n);
ref_redc_1 (cp1, tp1, mp, n, inv);
mpn_redc_1 (cp2, tp2, mp, n, inv);
if (mpn_cmp (cp1, cp2, n) != 0)
{
printf ("mpn_redc_1 error %d\n", n);
abort ();
}
if (n != 1 && mpn_cmp (tp1, tp2, 2 * n) != 0)
{
printf ("mpn_redc_1 possible error\n");
abort ();
}
/* we dont require the above to be the same but it could be a useful test */
}
}
for (n = 1; n < 100; n++)
{
for (j = 1; j < 100; j++)
{
mpn_rrandom (mp, rands, n);
mp[0] |= 1;
modlimb_invert (inv, mp[0]);
inv = -inv;
mpn_rrandom (tp1, rands, 2 * n);
MPN_COPY (tp2, tp1, 2 * n);
ref_redc_1 (cp1, tp1, mp, n, inv);
mpn_redc_1 (cp2, tp2, mp, n, inv);
if (mpn_cmp (cp1, cp2, n) != 0)
{
printf ("mpn_redc_1 error %d\n", n);
abort ();
}
if (n != 1 && mpn_cmp (tp1, tp2, 2 * n) != 0)
{
printf ("mpn_redc_1 possible error\n");
abort ();
}
/* we dont require the above to be the same but it could be a useful test */
}
}
gmp_randclear (rands);
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_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
unsigned long r_rq, r_q, r_r, r;
tests_start ();
rands = 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_tdiv_qr_ui (quotient, remainder, dividend, divisor);
r_q = mpz_tdiv_q_ui (quotient2, dividend, divisor);
r_r = mpz_tdiv_r_ui (remainder2, dividend, divisor);
r = mpz_tdiv_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_tdiv_qr_ui and mpz_tdiv_q_ui differ",
dividend, divisor);
if (mpz_cmp (remainder, remainder2) != 0)
dump_abort ("remainders from mpz_tdiv_qr_ui and mpz_tdiv_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 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 ("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_tdiv_qr_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r_q) != 0)
dump_abort ("remainder returned from mpz_tdiv_q_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r_r) != 0)
dump_abort ("remainder returned from mpz_tdiv_r_ui is wrong",
dividend, divisor);
if (mpz_cmp_ui (remainder, r) != 0)
dump_abort ("remainder returned from mpz_tdiv_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);
tests_end ();
exit (0);
}
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);
}
int
main (void)
{
mpz_t z;
int got;
const char *expr;
int error = 0;
tests_start ();
mpz_init (z);
mpz_set_ui (z, 0L);
expr = "0";
EXPECT (mpz_fits_ulong_p, 1);
EXPECT (mpz_fits_uint_p, 1);
EXPECT (mpz_fits_ushort_p, 1);
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
EXPECT (mpz_fits_sshort_p, 1);
mpz_set_ui (z, 1L);
expr = "1";
EXPECT (mpz_fits_ulong_p, 1);
EXPECT (mpz_fits_uint_p, 1);
EXPECT (mpz_fits_ushort_p, 1);
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
EXPECT (mpz_fits_sshort_p, 1);
mpz_set_si (z, -1L);
expr = "-1";
EXPECT (mpz_fits_ulong_p, 0);
EXPECT (mpz_fits_uint_p, 0);
EXPECT (mpz_fits_ushort_p, 0);
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
EXPECT (mpz_fits_sshort_p, 1);
mpz_set_ui (z, 1L);
mpz_mul_2exp (z, z, 5L*BITS_PER_MP_LIMB);
expr = "2^(5*BPML)";
EXPECT (mpz_fits_ulong_p, 0);
EXPECT (mpz_fits_uint_p, 0);
EXPECT (mpz_fits_ushort_p, 0);
EXPECT (mpz_fits_slong_p, 0);
EXPECT (mpz_fits_sint_p, 0);
EXPECT (mpz_fits_sshort_p, 0);
mpz_set_ui (z, (unsigned long) USHRT_MAX);
expr = "USHRT_MAX";
EXPECT (mpz_fits_ulong_p, 1);
EXPECT (mpz_fits_uint_p, 1);
EXPECT (mpz_fits_ushort_p, 1);
mpz_set_ui (z, (unsigned long) USHRT_MAX);
mpz_add_ui (z, z, 1L);
expr = "USHRT_MAX + 1";
EXPECT (mpz_fits_ushort_p, 0);
mpz_set_ui (z, (unsigned long) UINT_MAX);
expr = "UINT_MAX";
EXPECT (mpz_fits_ulong_p, 1);
EXPECT (mpz_fits_uint_p, 1);
mpz_set_ui (z, (unsigned long) UINT_MAX);
mpz_add_ui (z, z, 1L);
expr = "UINT_MAX + 1";
EXPECT (mpz_fits_uint_p, 0);
mpz_set_ui (z, ULONG_MAX);
expr = "ULONG_MAX";
EXPECT (mpz_fits_ulong_p, 1);
mpz_set_ui (z, ULONG_MAX);
mpz_add_ui (z, z, 1L);
expr = "ULONG_MAX + 1";
EXPECT (mpz_fits_ulong_p, 0);
mpz_set_si (z, (long) SHRT_MAX);
expr = "SHRT_MAX";
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
EXPECT (mpz_fits_sshort_p, 1);
mpz_set_si (z, (long) SHRT_MAX);
mpz_add_ui (z, z, 1L);
expr = "SHRT_MAX + 1";
EXPECT (mpz_fits_sshort_p, 0);
mpz_set_si (z, (long) INT_MAX);
expr = "INT_MAX";
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
mpz_set_si (z, (long) INT_MAX);
mpz_add_ui (z, z, 1L);
expr = "INT_MAX + 1";
EXPECT (mpz_fits_sint_p, 0);
mpz_set_si (z, LONG_MAX);
expr = "LONG_MAX";
EXPECT (mpz_fits_slong_p, 1);
mpz_set_si (z, LONG_MAX);
mpz_add_ui (z, z, 1L);
expr = "LONG_MAX + 1";
EXPECT (mpz_fits_slong_p, 0);
mpz_set_si (z, (long) SHRT_MIN);
expr = "SHRT_MIN";
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
EXPECT (mpz_fits_sshort_p, 1);
mpz_set_si (z, (long) SHRT_MIN);
mpz_sub_ui (z, z, 1L);
expr = "SHRT_MIN + 1";
EXPECT (mpz_fits_sshort_p, 0);
mpz_set_si (z, (long) INT_MIN);
expr = "INT_MIN";
EXPECT (mpz_fits_slong_p, 1);
EXPECT (mpz_fits_sint_p, 1);
mpz_set_si (z, (long) INT_MIN);
mpz_sub_ui (z, z, 1L);
expr = "INT_MIN + 1";
EXPECT (mpz_fits_sint_p, 0);
mpz_set_si (z, LONG_MIN);
expr = "LONG_MIN";
EXPECT (mpz_fits_slong_p, 1);
mpz_set_si (z, LONG_MIN);
mpz_sub_ui (z, z, 1L);
expr = "LONG_MIN + 1";
EXPECT (mpz_fits_slong_p, 0);
if (error)
abort ();
mpz_clear (z);
tests_end ();
exit (0);
}
