int main(void) { int i, result; flint_rand_t state; printf("init_set...."); fflush(stdout); flint_randinit(state); /* Small integers */ for (i = 0; i < 100000; i++) { fmpz_t a, b; fmpz_init(a); fmpz_randtest(a, state, FLINT_BITS - 2); fmpz_init_set(b, a); result = fmpz_equal(a, b); if (!result) { printf("FAIL:\n\n"); printf("a = "), fmpz_print(a), printf("\n"); printf("b = "), fmpz_print(b), printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(b); } /* Large integers */ for (i = 0; i < 100000; i++) { fmpz_t a, b; fmpz_init(a); fmpz_randtest(a, state, 2 * FLINT_BITS); fmpz_init_set(b, a); result = fmpz_equal(a, b); if (!result) { printf("FAIL:\n\n"); printf("a = "), fmpz_print(a), printf("\n"); printf("b = "), fmpz_print(b), printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(b); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { flint_rand_t state; slong i; flint_printf("partitions_fmpz_ui_threaded...."); fflush(stdout); flint_randinit(state); flint_set_num_threads(2); { fmpz_t p; fmpz * v; fmpz_init(p); v = _fmpz_vec_init(NUM); arith_number_of_partitions_vec(v, NUM); for (i = 0; i < NUM; i++) { partitions_fmpz_ui(p, i); if (!fmpz_equal(p, v + i)) { flint_printf("FAIL:\n"); flint_printf("p(%wd) does not agree with power series\n", i); flint_printf("Computed p(%wd): ", i); fmpz_print(p); flint_printf("\n"); flint_printf("Expected: "); fmpz_print(v + i); flint_printf("\n"); abort(); } } _fmpz_vec_clear(v, NUM); for (i = 0; testdata[i][0] != 0; i++) { partitions_fmpz_ui(p, testdata[i][0]); if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1]) { flint_printf("FAIL:\n"); flint_printf("p(%wd) does not agree with known value mod 10^9\n", testdata[i][0]); flint_printf("Computed: %wu\n", fmpz_fdiv_ui(p, 1000000000)); flint_printf("Expected: %wu\n", testdata[i][1]); abort(); } } fmpz_clear(p); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return 0; }
void test_1(fmpz_t n) { mpfr_t q0; mpfr_init(q0); mpfr_t q1; mpfr_init(q1); fmpz_t m; fmpz_init(m); int c; fmpz_get_mpfr( q0, n , MPFR_RNDA ); fmpz_get_mpfr_3arg(q1, n[0], MPFR_RNDA ); assert( mpfr_equal_p( q0, q1 ) ); fmpz_set_mpfr(m, q0, MPFR_RNDA); if( fmpz_cmp_ui( n, WORD(0) ) >= 0 ) { if( fmpz_cmp(n,m) > 0 ) { flint_printf("RNDA test failed, n="); fmpz_print(n); flint_printf(", m="); fmpz_print(m); flint_printf("\n"); assert(0); } fmpz_sub(m, m, n); IF_MORE_THAN_2; } else { if( fmpz_cmp(n,m) < 0 ) { flint_printf("RNDA test failed, n="); fmpz_print(n); flint_printf(", m="); fmpz_print(m); flint_printf("\n"); assert(0); } fmpz_sub(m, n, m); IF_MORE_THAN_2; } fmpz_get_mpfr( q0, n, MPFR_RNDZ ); fmpz_set_mpfr( m, q0, MPFR_RNDZ ); c=fmpz_cmp_si( n, WORD(0) ); if(c==0) assert(0 == fmpz_cmp_si(m,WORD(0))); else { if(c<0) { fmpz_neg(n, n); fmpz_neg(m, m); } assert( fmpz_cmp(n,m) >= 0 ); if(c) assert( fmpz_cmp_si(m,WORD(0)) >= 0 ); fmpz_sub(m, n, m); IF_MORE_THAN_2_AGAIN; } fmpz_clear(m); mpfr_clear(q1); mpfr_clear(q0); }
int main(void) { flint_rand_t state; fmpz_t p; fmpz * v; long i; printf("number_of_partitions...."); fflush(stdout); flint_randinit(state); fmpz_init(p); v = _fmpz_vec_init(3000); number_of_partitions_vec(v, 3000); for (i = 0; i < 3000; i++) { number_of_partitions(p, i); if (!fmpz_equal(p, v + i)) { printf("FAIL:\n"); printf("p(%ld) does not agree with power series\n", i); printf("Computed p(%ld): ", i); fmpz_print(p); printf("\n"); printf("Expected: "); fmpz_print(v + i); printf("\n"); abort(); } } _fmpz_vec_clear(v, 3000); for (i = 0; testdata[i][0] != 0; i++) { number_of_partitions(p, testdata[i][0]); if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1]) { printf("FAIL:\n"); printf("p(%ld) does not agree with known value mod 10^9\n", testdata[i][0]); printf("Computed: %lu\n", fmpz_fdiv_ui(p, 1000000000)); printf("Expected: %lu\n", testdata[i][1]); abort(); } } fmpz_clear(p); flint_randclear(state); mpfr_free_cache(); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("get_interval_fmpz_2exp...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t x; arf_t y; fmpz_t a, b, exp; arb_init(x); arf_init(y); fmpz_init(a); fmpz_init(b); fmpz_init(exp); arb_randtest(x, state, 200, 10); arb_get_interval_fmpz_2exp(a, b, exp, x); arf_set_fmpz_2exp(y, a, exp); if (!arb_contains_arf(x, y)) { flint_printf("FAIL:\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("a = "); fmpz_print(a); flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n"); abort(); } arf_set_fmpz_2exp(y, b, exp); if (!arb_contains_arf(x, y)) { flint_printf("FAIL:\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("b = "); fmpz_print(b); flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n"); abort(); } arb_clear(x); arf_clear(y); fmpz_clear(a); fmpz_clear(b); fmpz_clear(exp); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("bell_sum_taylor...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t s1, s2; fmpz_t a, b, n; slong prec; arb_init(s1); arb_init(s2); fmpz_init(a); fmpz_init(b); fmpz_init(n); prec = 2 + n_randint(state, 300); fmpz_randtest_unsigned(n, state, 1 + n_randint(state, 100)); fmpz_randtest_unsigned(a, state, 1 + n_randint(state, 100)); fmpz_add_ui(b, a, n_randint(state, 100)); arb_bell_sum_bsplit(s1, n, a, b, NULL, prec); arb_bell_sum_taylor(s2, n, a, b, NULL, prec); if (!arb_overlaps(s1, s2) || (arb_rel_accuracy_bits(s1) < prec - 4) || (arb_rel_accuracy_bits(s2) < prec - 4)) { flint_printf("FAIL: overlap or accuracy\n\n"); flint_printf("prec = %wd\n\n", prec); flint_printf("n = "); fmpz_print(n); flint_printf("\n\n"); flint_printf("a = "); fmpz_print(a); flint_printf("\n\n"); flint_printf("b = "); fmpz_print(b); flint_printf("\n\n"); flint_printf("s1 = "); arb_printn(s1, 100, 0); flint_printf("\n\n"); flint_printf("s2 = "); arb_printn(s2, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(s1); arb_clear(s2); fmpz_clear(a); fmpz_clear(b); fmpz_clear(n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { fmpz_t p; fmpz * v; slong i; FLINT_TEST_INIT(state); flint_printf("number_of_partitions...."); fflush(stdout); fmpz_init(p); v = _fmpz_vec_init(3000); arith_number_of_partitions_vec(v, 3000); for (i = 0; i < 3000; i++) { arith_number_of_partitions(p, i); if (!fmpz_equal(p, v + i)) { flint_printf("FAIL:\n"); flint_printf("p(%wd) does not agree with power series\n", i); flint_printf("Computed p(%wd): ", i); fmpz_print(p); flint_printf("\n"); flint_printf("Expected: "); fmpz_print(v + i); flint_printf("\n"); abort(); } } _fmpz_vec_clear(v, 3000); for (i = 0; testdata[i][0] != 0; i++) { arith_number_of_partitions(p, testdata[i][0]); if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1]) { flint_printf("FAIL:\n"); flint_printf("p(%wd) does not agree with known value mod 10^9\n", testdata[i][0]); flint_printf("Computed: %wu\n", fmpz_fdiv_ui(p, 1000000000)); flint_printf("Expected: %wu\n", testdata[i][1]); abort(); } } fmpz_clear(p); FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("lshift_mpn...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { fmpz_t a, b, c; ulong e; mp_limb_t atmp; mp_ptr aptr; mp_size_t an; int asgnbit; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_randtest_not_zero(a, state, 1 + n_randint(state, 2000)); fmpz_randtest(b, state, 1 + n_randint(state, 2000)); fmpz_randtest(c, state, 1 + n_randint(state, 2000)); e = n_randint(state, 1000); FMPZ_GET_MPN_READONLY(asgnbit, an, aptr, atmp, *a) fmpz_lshift_mpn(b, aptr, an, asgnbit, e); fmpz_mul_2exp(c, a, e); if (!fmpz_equal(b, c)) { flint_printf("FAIL\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); flint_abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("set_fmpz_2exp...."); fflush(stdout); flint_randinit(state); /* test exact roundtrip R -> Q -> R */ for (iter = 0; iter < 100000; iter++) { slong bits; fmpr_t x, z; fmpz_t y, e; bits = 2 + n_randint(state, 200); fmpr_init(x); fmpr_init(z); fmpz_init(y); fmpz_init(e); fmpr_randtest(x, state, bits, 10); fmpr_randtest(z, state, bits, 10); fmpr_get_fmpz_2exp(y, e, x); fmpr_set_fmpz_2exp(z, y, e); if (!fmpr_equal(x, z)) { flint_printf("FAIL\n\n"); flint_printf("bits: %wd\n", bits); flint_printf("x = "); fmpr_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpz_print(y); flint_printf("\n\n"); flint_printf("e = "); fmpz_print(e); flint_printf("\n\n"); flint_printf("z = "); fmpr_print(z); flint_printf("\n\n"); abort(); } fmpr_clear(x); fmpr_clear(z); fmpz_clear(y); fmpz_clear(e); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("set_si...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq_t x, y; fmpz_t p, q; slong P, Q; fmpq_init(x); fmpq_init(y); fmpz_init(p); fmpz_init(q); P = z_randtest(state); Q = n_randtest_not_zero(state); fmpz_set_si(p, P); fmpz_set_ui(q, Q); fmpq_set_fmpz_frac(x, p, q); fmpq_set_si(y, P, Q); if (!fmpq_is_canonical(y) || !fmpq_equal(x, y)) { flint_printf("FAIL"); flint_printf("p: "); fmpz_print(p); flint_printf("\n"); flint_printf("q: "); fmpz_print(q); flint_printf("\n"); flint_printf("x: "); fmpq_print(x); flint_printf("\n"); flint_printf("y: "); fmpq_print(y); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(p); fmpz_clear(q); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; printf("setbit...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 100000; i++) { ulong j; fmpz_t a, c; mpz_t b; fmpz_init(a); fmpz_init(c); mpz_init(b); fmpz_randtest(a, state, 2 * FLINT_BITS); fmpz_get_mpz(b, a); j = n_randint(state, 3 * FLINT_BITS); fmpz_setbit(a, j); mpz_setbit(b, j); fmpz_set_mpz(c, b); result = (fmpz_equal(a, c)); if (!result) { printf("FAIL:\n"); printf("a = "), fmpz_print(a), printf("\n"); gmp_printf("b = %Zd\n", b); printf("c = "), fmpz_print(c), printf("\n"); printf("j = %ld\n", j); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(b); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("content...."); fflush(stdout); /* Check that content(a f) = abs(a) content(f) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a, c, d; fmpz *f; slong len = n_randint(state, 100); fmpz_init(a); fmpz_init(c); fmpz_init(d); f = _fmpz_vec_init(len); _fmpz_vec_randtest(f, state, len, 200); fmpz_randtest(a, state, 100); _fmpz_vec_content(c, f, len); _fmpz_vec_scalar_mul_fmpz(f, f, len, a); fmpz_abs(a, a); fmpz_mul(c, a, c); _fmpz_vec_content(d, f, len); result = (fmpz_equal(c, d)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(c), flint_printf("\n\n"); fmpz_print(d), flint_printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(c); fmpz_clear(d); _fmpz_vec_clear(f, len); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { fmpz * num1; fmpz * den1; fmpz_t num2; fmpz_t den2; long n, N; printf("bernoulli_number...."); fflush(stdout); N = 4000; num1 = _fmpz_vec_init(N); den1 = _fmpz_vec_init(N); fmpz_init(num2); fmpz_init(den2); _bernoulli_number_vec_multi_mod(num1, den1, N); for (n = 0; n < N; n++) { bernoulli_number(num2, den2, n); if (!fmpz_equal(num1 + n, num2)) { printf("FAIL: n = %ld, numerator\n", n); printf("vec: "); fmpz_print(num1 + n); printf("\n"); printf("single: "); fmpz_print(num2); printf("\n"); abort(); } if (!fmpz_equal(den1 + n, den2)) { printf("FAIL: n = %ld, denominator\n", n); printf("vec: "); fmpz_print(den1 + n); printf("\n"); printf("single: "); fmpz_print(den2); printf("\n"); abort(); } } _fmpz_vec_clear(num1, N); _fmpz_vec_clear(den1, N); fmpz_clear(num2); fmpz_clear(den2); mpfr_free_cache(); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { fmpz * num1; fmpz * den1; fmpz_t num2; fmpz_t den2; slong n, N; flint_printf("fmpq_ui...."); fflush(stdout); N = 4000; num1 = _fmpz_vec_init(N); den1 = _fmpz_vec_init(N); fmpz_init(num2); fmpz_init(den2); _arith_bernoulli_number_vec_multi_mod(num1, den1, N); for (n = 0; n < N; n++) { _bernoulli_fmpq_ui(num2, den2, n); if (!fmpz_equal(num1 + n, num2)) { flint_printf("FAIL: n = %wd, numerator\n", n); flint_printf("vec: "); fmpz_print(num1 + n); flint_printf("\n"); flint_printf("single: "); fmpz_print(num2); flint_printf("\n"); abort(); } if (!fmpz_equal(den1 + n, den2)) { flint_printf("FAIL: n = %wd, denominator\n", n); flint_printf("vec: "); fmpz_print(den1 + n); flint_printf("\n"); flint_printf("single: "); fmpz_print(den2); flint_printf("\n"); abort(); } } _fmpz_vec_clear(num1, N); _fmpz_vec_clear(den1, N); fmpz_clear(num2); fmpz_clear(den2); flint_cleanup(); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("set_ui_smod...."); fflush(stdout); for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, b, mz; mp_limb_t m, r; fmpz_init(a); fmpz_init(b); fmpz_init(mz); do { m = n_randtest(state); } while (m < 2); fmpz_set_ui(mz, m); fmpz_randtest_mod_signed(a, state, mz); r = fmpz_fdiv_ui(a, m); fmpz_set_ui_smod(b, r, m); if (!fmpz_equal(a, b)) { flint_printf("FAIL:\n"); flint_printf("a: "); fmpz_print(a); flint_printf("\n"); flint_printf("m: %wu\n", m); flint_printf("r: %wu\n", m); flint_printf("b: "); fmpz_print(b); flint_printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(mz); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(int argc, char* argv[]) { fmpz_t c, n; long N = 0; if (argc == 2) N = atol(argv[1]); if (argc != 2 || N < 1) { printf("Syntax: delta_qexp <integer>\n"); printf("where <integer> is the (positive) number of terms to compute\n"); return EXIT_FAILURE; } fmpz_init(c); fmpz_init(n); fmpz_set_si(n, N); fmpz_ramanujan_tau(c, n); printf("Coefficient of q^%ld is ", N); fmpz_print(c); printf("\n"); fmpz_clear(c); fmpz_clear(n); return EXIT_SUCCESS; }
int fmpq_poly_debug(const fmpq_poly_t poly) { long i; printf("{alloc: %ld, length: %ld, coeffs:", poly->alloc, poly->length); for (i = 0; i < poly->alloc; i++) { printf(" "); fmpz_print(poly->coeffs + i); } printf(", den: "); fmpz_print(poly->den); printf("}"); return 1; }
int main(void) { long i, n; fmpz_t x, y, z, w; printf("fib_ui...."); fflush(stdout); fmpz_init(x); fmpz_init(y); fmpz_init(z); fmpz_init(w); /* Twice to check demotion */ for (n = 0; n < 2; n++) { for (i = 0; i < 200; i++) { fmpz_fib_ui(x, i); fmpz_fib_ui(y, i+1); fmpz_fib_ui(z, i+2); fmpz_add(w, x, y); if (!fmpz_equal(w, z)) { printf("FAIL: %ld\n", i); fmpz_print(x); printf("\n"); fmpz_print(y); printf("\n"); fmpz_print(z); printf("\n"); abort(); } } } fmpz_clear(x); fmpz_clear(y); fmpz_clear(z); fmpz_clear(w); _fmpz_cleanup(); printf("PASS\n"); return 0; }
static void check(fmpz_t x, int expected) { if (fmpz_abs_fits_ui(x) != expected) { printf("FAIL:\n\n"); printf("x = "), fmpz_print(x), printf("\n"); abort(); } }
int main(void) { int i, result; flint_rand_t state; printf("dlog...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 10000; i++) { fmpz_t x; mpz_t z; mpfr_t r; double y, w; fmpz_init(x); mpz_init(z); mpfr_init2(r, 53); fmpz_randtest_not_zero(x, state, 10000); fmpz_abs(x, x); y = fmpz_dlog(x); fmpz_get_mpz(z, x); mpfr_set_z(r, z, MPFR_RNDN); mpfr_log(r, r, MPFR_RNDN); w = mpfr_get_d(r, MPFR_RNDN); result = (FLINT_ABS(y - w) <= w * 1e-13); if (!result) { printf("FAIL:\n"); printf("x = "), fmpz_print(x), printf("\n"); printf("y = %.20g\n", y); printf("w = %.20g\n", w); abort(); } fmpz_clear(x); mpz_clear(z); mpfr_clear(r); } mpfr_free_cache(); flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("abs_bound_le_2exp_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arf_t x, y; fmpz_t b; int cmp1, cmp2; arf_init(x); arf_init(y); fmpz_init(b); arf_randtest_not_zero(x, state, 2 + n_randint(state, 1000), 100); arf_abs_bound_le_2exp_fmpz(b, x); arf_one(y); arf_mul_2exp_fmpz(y, y, b); cmp1 = (arf_cmpabs(x, y) <= 0); arf_mul_2exp_si(y, y, -1); cmp2 = (arf_cmpabs(y, x) < 0); arf_mul_2exp_si(y, y, 1); if (!cmp1 || !cmp2) { flint_printf("FAIL\n\n"); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); arf_print(y); flint_printf("\n\n"); flint_printf("b = "); fmpz_print(b); flint_printf("\n\n"); flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2); abort(); } arf_clear(x); arf_clear(y); fmpz_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
static void check(fmpz_t x, int expected) { if (fmpz_fits_si(x) != expected) { printf("FAIL:\n\n"); printf("x = "), fmpz_print(x), printf("\n"); printf("fmpz_fits_si(x) = %d\n", fmpz_fits_si(x)); printf("LONG_MIN = %ld\n", LONG_MIN); abort(); } }
int main(void) { long i, n; fmpz_t x; fmpz_t y; printf("fac_ui...."); fflush(stdout); fmpz_init(x); fmpz_init(y); /* Twice to check demotion */ for (n = 0; n < 2; n++) { fmpz_set_ui(y, 1UL); for (i = 0; i < 100; i++) { fmpz_fac_ui(x, i); fmpz_mul_ui(y, y, FLINT_MAX(1, i)); if (!fmpz_equal(x, y)) { printf("FAIL: %ld\n", i); fmpz_print(x); printf("\n"); fmpz_print(y); printf("\n"); abort(); } } } fmpz_clear(x); fmpz_clear(y); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; printf("evaluate_mod...."); fflush(stdout); flint_randinit(state); /* Compare with evaluation over the integers */ for (i = 0; i < 10000; i++) { fmpz_t b, s; fmpz_poly_t f; mp_limb_t a, n, r; fmpz_poly_init(f); fmpz_poly_randtest(f, state, n_randint(state, 10), 20); n = n_randtest_not_zero(state); a = n_randint(state, n); fmpz_init(b); fmpz_init(s); fmpz_set_ui(b, a); r = fmpz_poly_evaluate_mod(f, a, n); fmpz_poly_evaluate_fmpz(s, f, b); result = (r == fmpz_mod_ui(s, s, n)); if (!result) { printf("FAIL:\n"); fmpz_poly_print(f), printf("\n\n"); gmp_printf("a = %Mu\n\n", a); gmp_printf("n = %Mu\n\n", n); gmp_printf("r = %Mu\n\n", r); printf("s = "), fmpz_print(s), printf("\n\n"); abort(); } fmpz_poly_clear(f); fmpz_clear(b); fmpz_clear(s); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("init_set_ui...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 100000; i++) { fmpz_t a, b; ulong x = n_randtest(state); fmpz_init(a); fmpz_set_ui(a, x); fmpz_init_set_ui(b, x); result = fmpz_equal(a, b); if (!result) { printf("FAIL:\n\n"); printf("a = "), fmpz_print(a), printf("\n"); printf("b = "), fmpz_print(b), printf("\n"); printf("x = %lu\n", x); abort(); } fmpz_clear(a); fmpz_clear(b); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("sub_si_inline...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { fmpz_t a, c, d; slong b; fmpz_init(a); fmpz_init(c); fmpz_init(d); fmpz_randtest(a, state, 1 + n_randint(state, 200)); fmpz_randtest(c, state, 1 + n_randint(state, 200)); fmpz_randtest(d, state, 1 + n_randint(state, 200)); b = n_randtest(state); fmpz_sub_si(c, a, b); fmpz_sub_si_inline(d, a, b); if (!fmpz_equal(c, d)) { flint_printf("FAIL\n"); fmpz_print(a); flint_printf("\n\n"); flint_printf("%wd", b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_sub_si_inline(a, a, b); if (!fmpz_equal(c, a)) { flint_printf("FAIL (aliasing)\n"); fmpz_print(a); flint_printf("\n\n"); flint_printf("%wd", b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(c); fmpz_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("height...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 10000; i++) { fmpz *a; fmpz_t h; long len, bits, bits2; fmpz_init(h); len = n_randint(state, 100); a = _fmpz_vec_init(len); bits = n_randint(state, 200); _fmpz_vec_randtest(a, state, len, bits); bits2 = _fmpz_vec_max_bits(a, len); _fmpz_vec_height(h, a, len); result = (fmpz_bits(h) == FLINT_ABS(bits2)) && (fmpz_sgn(h) >= 0); if (!result) { printf("FAIL:\n"); printf("bits = %ld, bits2 = %ld\n", bits, bits2); printf("Computed height:\n"); fmpz_print(h); printf("\n"); abort(); } fmpz_clear(h); _fmpz_vec_clear(a, len); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
static void fmpz_mat_window_unsh_print(const char* m,const MATR A) { #if 0 printf("\n%s\n",m); slong i,j; for(i=0;i<A->r;i++) { for(j=0;j<A->c;j++) { //printf("%ld ",(slong)(fmpz_mat_window_entry(A,i,j))); fmpz_print( A->rows[i]+j ); printf(" "); } printf("\n"); } printf("\n"); #endif }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("get_coeff_ptr...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_poly_t A; fmpz_t a; slong n = n_randint(state, 100); fmpz_poly_init(A); fmpz_poly_randtest(A, state, n_randint(state, 100), 100); fmpz_init(a); fmpz_poly_get_coeff_fmpz(a, A, n); result = n < fmpz_poly_length(A) ? fmpz_equal(a, fmpz_poly_get_coeff_ptr(A, n)) : fmpz_poly_get_coeff_ptr(A, n) == NULL; if (!result) { flint_printf("FAIL:\n"); flint_printf("A = "), fmpz_poly_print(A), flint_printf("\n\n"); flint_printf("a = "), fmpz_print(a), flint_printf("\n\n"); flint_printf("n = %wd\n\n", n); abort(); } fmpz_poly_clear(A); fmpz_clear(a); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int check_ceil(renf_elem_t a, renf_t nf, int ans, const char * s) { fmpz_t n; int test; fmpz_init(n); renf_elem_ceil(n, a, nf); test = fmpz_cmp_si(n, ans); fmpz_clear(n); if (test) { printf("FAIL:\n"); printf("a = "); renf_elem_print_pretty(a, s, nf, 10, EANTIC_STR_ALG & EANTIC_STR_D); printf("\n"); printf("got n = "); fmpz_print(n); printf(" but expected %d\n", ans); abort(); } return 0; }