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); }