int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("is_square...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_mat_t A; slong rows = n_randint(state, 10); slong cols = n_randint(state, 10); fmpz_mat_init(A, rows, cols); if (fmpz_mat_is_square(A) != (rows == cols)) { flint_printf("FAIL!\n"); abort(); } fmpz_mat_clear(A); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int iter; FLINT_TEST_INIT(state); flint_printf("inflate...."); fflush(stdout); for (iter = 0; iter < 100 * flint_test_multiplier(); iter++) { nmod_poly_t poly1, poly2, poly3, xp; mp_limb_t modulus; ulong inflation; modulus = n_randtest_prime(state, 0); nmod_poly_init(poly1, modulus); nmod_poly_init(poly2, modulus); nmod_poly_init(poly3, modulus); nmod_poly_init(xp, modulus); nmod_poly_randtest(poly1, state, n_randint(state, 20)); inflation = n_randint(state, 10); nmod_poly_inflate(poly2, poly1, inflation); nmod_poly_set_coeff_ui(xp, inflation, 1); nmod_poly_compose(poly3, poly1, xp); if (!nmod_poly_equal(poly2, poly3)) { flint_printf("FAIL: not equal to compose (inflation = %wu)\n", inflation); flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n"); flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n"); flint_printf("poly3:\n"); nmod_poly_print(poly3); flint_printf("\n\n"); abort(); } nmod_poly_inflate(poly1, poly1, inflation); if (!nmod_poly_equal(poly1, poly2)) { flint_printf("FAIL: aliasing (inflation = %wu)\n", inflation); flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n"); flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n"); abort(); } nmod_poly_clear(poly1); nmod_poly_clear(poly2); nmod_poly_clear(poly3); nmod_poly_clear(xp); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("init/clear...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_mat_t a; slong j, k; slong rows = n_randint(state, 100); slong cols = n_randint(state, 100); fmpq_mat_init(a, rows, cols); for (j = 0; j < rows; j++) for (k = 0; k < cols; k++) fmpq_zero(fmpq_mat_entry(a, j, k)); fmpq_mat_clear(a); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { mp_limb_t n; int j; FLINT_TEST_INIT(state); flint_printf("factorial_mod2_preinv...."); fflush(stdout); for (n = 0; n < 100 * flint_test_multiplier(); n++) { mp_limb_t p, pinv, x, y; for (j = 0; j < 10; j++) { p = n_randtest_not_zero(state); pinv = n_preinvert_limb(p); x = n_factorial_mod2_preinv(n, p, pinv); y = n_factorial_mod2_foolproof(n, p, pinv); if (x != y) { flint_printf("FAIL:\n"); flint_printf("n = %wu\np = %wu\nx = %wu\ny = %wu\n", n, p, x, y); abort(); } } } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("one...."); fflush(stdout); /* 1 * A == A * 1 == A */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpq_mat_t A, B, C, I; slong n, bits; n = n_randint(state, 10); bits = 1 + n_randint(state, 100); fmpq_mat_init(A, n, n); fmpq_mat_init(B, n, n); fmpq_mat_init(C, n, n); fmpq_mat_init(I, n, n); fmpq_mat_randtest(A, state, bits); fmpq_mat_one(I); fmpq_mat_mul(B, I, A); fmpq_mat_mul(C, A, I); result = fmpq_mat_equal(A, B) && fmpq_mat_equal(A, C); if (!result) { flint_printf("FAIL:\n"); flint_printf("A:\n"); fmpq_mat_print(A); flint_printf("B:\n"); fmpq_mat_print(B); flint_printf("C:\n"); fmpq_mat_print(C); flint_printf("I:\n"); fmpq_mat_print(I); abort(); } fmpq_mat_clear(A); fmpq_mat_clear(B); fmpq_mat_clear(C); fmpq_mat_clear(I); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mullow_classical... "); fflush(stdout); /* Compare with truncated product of a and b */ for (i = 0; i < 2000; i++) { TEMPLATE(T, ctx_t) ctx; TEMPLATE(T, poly_t) a, b, c, d; slong n; TEMPLATE(T, ctx_randtest) (ctx, state); TEMPLATE(T, poly_init) (a, ctx); TEMPLATE(T, poly_init) (b, ctx); TEMPLATE(T, poly_init) (c, ctx); TEMPLATE(T, poly_init) (d, ctx); TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 50), ctx); TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 50), ctx); n = n_randint(state, 50); TEMPLATE(T, poly_mullow_classical) (c, a, b, n, ctx); TEMPLATE(T, poly_mul) (d, a, b, ctx); TEMPLATE(T, poly_truncate) (d, n, ctx); result = (TEMPLATE(T, poly_equal) (c, d, ctx)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), TEMPLATE(T, poly_print_pretty) (a, "X", ctx), flint_printf("\n"); flint_printf("b = "), TEMPLATE(T, poly_print_pretty) (b, "X", ctx), flint_printf("\n"); flint_printf("c = "), TEMPLATE(T, poly_print_pretty) (c, "X", ctx), flint_printf("\n"); flint_printf("d = "), TEMPLATE(T, poly_print_pretty) (d, "X", ctx), flint_printf("\n"); abort(); } TEMPLATE(T, poly_clear) (a, ctx); TEMPLATE(T, poly_clear) (b, ctx); TEMPLATE(T, poly_clear) (c, ctx); TEMPLATE(T, poly_clear) (d, ctx); TEMPLATE(T, ctx_clear) (ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { slong i; FLINT_TEST_INIT(state); flint_printf("pow...."); fflush(stdout); for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_mat_t A, B, C; slong i, n; ulong e; n = n_randint(state, 10); e = n_randint(state, 20); fmpz_mat_init(A, n, n); fmpz_mat_init(B, n, n); fmpz_mat_init(C, n, n); fmpz_mat_randtest(A, state, n_randint(state, 200) + 1); fmpz_mat_randtest(B, state, n_randint(state, 200) + 1); /* Make sure noise in the output is ok */ fmpz_mat_randtest(B, state, n_randint(state, 200) + 1); fmpz_mat_pow(B, A, e); fmpz_mat_one(C); for (i = 0; i < e; i++) fmpz_mat_mul(C, C, A); if (!fmpz_mat_equal(C, B)) { flint_printf("FAIL: results not equal\n"); abort(); } fmpz_mat_pow(A, A, e); if (!fmpz_mat_equal(A, B)) { flint_printf("FAIL: aliasing failed\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(C); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { fmpz_mat_t A, B, C, D; slong i; FLINT_TEST_INIT(state); flint_printf("mul...."); fflush(stdout); for (i = 0; i < 100 * flint_test_multiplier(); i++) { slong m, n, k; m = n_randint(state, 50); n = n_randint(state, 50); k = n_randint(state, 50); fmpz_mat_init(A, m, n); fmpz_mat_init(B, n, k); fmpz_mat_init(C, m, k); fmpz_mat_init(D, m, k); fmpz_mat_randtest(A, state, n_randint(state, 200) + 1); fmpz_mat_randtest(B, state, n_randint(state, 200) + 1); /* Make sure noise in the output is ok */ fmpz_mat_randtest(C, state, n_randint(state, 200) + 1); fmpz_mat_mul(C, A, B); fmpz_mat_mul_classical_inline(D, A, B); if (!fmpz_mat_equal(C, D)) { flint_printf("FAIL: results not equal\n"); abort(); } fmpz_mat_mul(A, A, B); if (!fmpz_mat_equal(A, C)) { flint_printf("FAIL: aliasing failed\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(C); fmpz_mat_clear(D); } FLINT_TEST_CLEANUP(state); flint_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++) { fmpq_poly_t f, g; fmpq_t a, b, c; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_init(a); fmpq_init(b); fmpq_init(c); fmpq_poly_randtest_not_zero(f, state, n_randint(state, 100) + 1, 100); fmpq_randtest_not_zero(a, state, 100); fmpq_poly_scalar_mul_fmpq(g, f, a); fmpq_poly_content(b, g); fmpq_poly_content(c, f); fmpq_mul(c, a, c); fmpq_abs(c, c); result = (fmpq_equal(b, c)); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_print(f), flint_printf("\n\n"); fmpq_poly_print(g), flint_printf("\n\n"); fmpq_print(a), flint_printf("\n\n"); fmpq_print(b), flint_printf("\n\n"); fmpq_print(c), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_clear(a); fmpq_clear(b); fmpq_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result = 1; FLINT_TEST_INIT(state); flint_printf("exp_series_monomial_ui...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t A, expA, res; slong n; mp_limb_t mod; ulong power; mp_limb_t coeff; mod = n_randtest_prime(state, 0); n = n_randtest(state) % 100; n = FLINT_MIN(n, mod); nmod_poly_init(A, mod); nmod_poly_init(expA, mod); nmod_poly_init(res, mod); coeff = n_randlimb(state) % mod; power = 1 + n_randint(state, 2*n + 1); nmod_poly_set_coeff_ui(A, power, coeff); nmod_poly_exp_series(expA, A, n); nmod_poly_exp_series_monomial_ui(res, coeff, power, n); result = nmod_poly_equal(expA, res); if (!result) { flint_printf("FAIL:\n"); flint_printf("n = %wd, mod = %wu\n", n, mod); flint_printf("power = %wu, coeff = %wu\n", power, coeff); flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n"); flint_printf("exp(A): "); nmod_poly_print(expA), flint_printf("\n\n"); flint_printf("res: "); nmod_poly_print(res), flint_printf("\n\n"); abort(); } nmod_poly_clear(A); nmod_poly_clear(expA); nmod_poly_clear(res); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result = 1; FLINT_TEST_INIT(state); flint_printf("interpolate_nmod_vec_fast...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t P, Q; mp_ptr x, y; mp_limb_t mod; slong j, n, npoints; mod = n_randtest_prime(state, 0); npoints = n_randint(state, FLINT_MIN(100, mod)); n = n_randint(state, npoints + 1); nmod_poly_init(P, mod); nmod_poly_init(Q, mod); x = _nmod_vec_init(npoints); y = _nmod_vec_init(npoints); nmod_poly_randtest(P, state, n); for (j = 0; j < npoints; j++) x[j] = j; nmod_poly_evaluate_nmod_vec_fast(y, P, x, npoints); nmod_poly_interpolate_nmod_vec_fast(Q, x, y, npoints); result = nmod_poly_equal(P, Q); if (!result) { flint_printf("FAIL:\n"); flint_printf("mod=%wu, n=%wd, npoints=%wd\n\n", mod, n, npoints); nmod_poly_print(P), flint_printf("\n\n"); nmod_poly_print(Q), flint_printf("\n\n"); abort(); } nmod_poly_clear(P); nmod_poly_clear(Q); _nmod_vec_clear(x); _nmod_vec_clear(y); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("parity...."); fflush(stdout); /* check inv(inv(a)) == a */ for (i = 0; i < 10000; i++) { slong n, *a, *b, *c; int ap, bp, cp, ap2, bp2, cp2; n = n_randint(state, 100); a = _perm_init(n); b = _perm_init(n); c = _perm_init(n); ap = _perm_randtest(a, n, state); bp = _perm_randtest(b, n, state); _perm_compose(c, a, b, n); cp = ap ^ bp; ap2 = _perm_parity(a, n); bp2 = _perm_parity(b, n); cp2 = _perm_parity(c, n); if (ap != ap2 || bp != bp2 || cp != cp2) { flint_printf("FAIL:\n"); flint_printf("a: "); _perm_print(a, n); flint_printf("\n\n"); flint_printf("b: "); _perm_print(b, n); flint_printf("\n\n"); flint_printf("c: "); _perm_print(c, n); flint_printf("\n\n"); flint_printf("ap = %d\n", ap); flint_printf("bp = %d\n", bp); flint_printf("cp = %d\n", cp); flint_printf("ap2 = %d\n", ap2); flint_printf("bp2 = %d\n", bp2); flint_printf("cp2 = %d\n", cp2); abort(); } _perm_clear(a); _perm_clear(b); _perm_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("scalar_submul_si_2exp...."); fflush(stdout); /* Compare with alternative method of computation */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz *a, *b, *c, *d; slong len = n_randint(state, 100), x; mp_bitcnt_t exp; a = _fmpz_vec_init(len); b = _fmpz_vec_init(len); c = _fmpz_vec_init(len); d = _fmpz_vec_init(len); _fmpz_vec_randtest(a, state, len, 200); _fmpz_vec_randtest(b, state, len, 200); _fmpz_vec_set(c, b, len); x = z_randtest(state); exp = n_randint(state, 200); _fmpz_vec_scalar_submul_si_2exp(b, a, len, x, exp); _fmpz_vec_scalar_mul_2exp(d, a, len, exp); _fmpz_vec_scalar_submul_si(c, d, len, x); result = (_fmpz_vec_equal(b, c, len)); if (!result) { flint_printf("FAIL:\n"); flint_printf("x = %wd, exp = %wu\n", x, exp); _fmpz_vec_print(b, len), flint_printf("\n\n"); _fmpz_vec_print(c, len), flint_printf("\n\n"); abort(); } _fmpz_vec_clear(a, len); _fmpz_vec_clear(b, len); _fmpz_vec_clear(c, len); _fmpz_vec_clear(d, len); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int iter; FLINT_TEST_INIT(state); flint_printf("sgn_eval_at_half...."); fflush(stdout); /* Check aliasing */ for (iter = 0; iter < 1000 * flint_test_multiplier(); iter++) { fmpz_t a; fmpz_poly_t f, g; long i, d; int s1, s2; fmpz_init(a); fmpz_poly_init(f); fmpz_poly_init(g); fmpz_poly_randtest(f, state, n_randint(state, 100), 200); s1 = fmpz_poly_sgn_eval_at_half(f); fmpz_poly_set(g, f); d = fmpz_poly_degree(g); for (i = 0; i <= d; i++) { fmpz_mul_2exp(fmpz_poly_get_coeff_ptr(g, i), fmpz_poly_get_coeff_ptr(g, i), d - i); } fmpz_one(a); fmpz_poly_evaluate_fmpz(a, g, a); s2 = fmpz_sgn(a); if (s1 != s2) { flint_printf("FAIL:\n"); fmpz_poly_print(f); printf("\n\n"); printf("s1 = %d, s2 = %d\n\n", s1, s2); abort(); } fmpz_clear(a); fmpz_poly_clear(f); fmpz_poly_clear(g); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
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(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; FLINT_TEST_INIT(state); flint_printf("cfrac_bound...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq_t x, r; fmpz * c; slong n, bound; fmpq_init(x); fmpq_init(r); /* Test worst case (quotient of Fibonacci numbers) */ if (n_randint(state, 50) == 1) { slong v = 1 + n_randint(state, 1000); fmpz_fib_ui(fmpq_numref(x), v + 1); fmpz_fib_ui(fmpq_denref(x), v); } else { fmpq_randtest(x, state, 1 + n_randint(state, 1000)); } bound = fmpq_cfrac_bound(x); c = _fmpz_vec_init(bound + 10); n = fmpq_get_cfrac(c, r, x, bound); if (n > bound) { flint_printf("FAIL: length=%wd > bound=%wd\n", n, bound); abort(); } _fmpz_vec_clear(c, bound + 10); fmpq_clear(x); fmpq_clear(r); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { fmpq_poly_t P, Q; mpz_t t; slong k, n; FLINT_TEST_INIT(state); flint_printf("bernoulli_polynomial...."); fflush(stdout); for (n = 0; n <= 100; n++) { fmpq_poly_init(P); fmpq_poly_init(Q); mpz_init(t); for (k = 0; k <= n; k++) { arith_bernoulli_polynomial(P, k); flint_mpz_bin_uiui(t, n+1, k); fmpq_poly_scalar_mul_mpz(P, P, t); fmpq_poly_add(Q, Q, P); } fmpq_poly_scalar_div_ui(Q, Q, n+1); mpz_clear(t); fmpq_poly_zero(P); fmpq_poly_set_coeff_ui(P, n, UWORD(1)); if (!fmpq_poly_equal(P, Q)) { flint_printf("ERROR: sum up to n = %wd did not add to x^n\n", n); flint_printf("Sum: "); fmpq_poly_print_pretty(Q, "x"); flint_printf("\nExpected: "); fmpq_poly_print_pretty(P, "x"); flint_printf("\n"); abort(); } fmpq_poly_clear(P); fmpq_poly_clear(Q); } FLINT_TEST_CLEANUP(state); flint_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(void) { mp_bitcnt_t depth, w; mp_size_t iters, j; double truncation; FLINT_TEST_INIT(state); flint_printf("mul_mfa_truncate_sqrt2...."); fflush(stdout); _flint_rand_init_gmp(state); depth = 13; w = 2; iters = 1; truncation = 0.5; { mp_size_t n = (UWORD(1)<<depth); mp_bitcnt_t bits1 = (n*w - (depth + 1))/2; mp_bitcnt_t bits = 2*n*bits1; mp_size_t int_limbs = ((mp_size_t)(truncation*bits))/FLINT_BITS; mp_size_t j; mp_limb_t * i1, *i2, *r1, *r2; flint_printf("limbs = %wd\n", int_limbs); i1 = flint_malloc(6*int_limbs*sizeof(mp_limb_t)); i2 = i1 + int_limbs; r1 = i2 + int_limbs; r2 = r1 + 2*int_limbs; flint_mpn_urandomb(i1, state->gmp_state, int_limbs*FLINT_BITS); flint_mpn_urandomb(i2, state->gmp_state, int_limbs*FLINT_BITS); for (j = 0; j < iters; j++) mul_mfa_truncate_sqrt2(r1, i1, int_limbs, i2, int_limbs, depth, w); //mpn_mul(r2, i1, int_limbs, i2, int_limbs); flint_free(i1); } flint_randclear(state); flint_printf("done\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("swap...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, c; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest(b, state, n_randint(state, 100)); fmpz_mod_poly_set(c, b); fmpz_mod_poly_swap(a, b); result = (fmpz_mod_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); fmpz_clear(p); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("dot_bound_limbs...."); fflush(stdout); for (i = 0; i < 1000000; i++) { slong len; nmod_t mod; mp_limb_t m; int limbs1, limbs2; mpz_t t; len = n_randint(state, 10000) + 1; m = n_randtest_not_zero(state); nmod_init(&mod, m); limbs1 = _nmod_vec_dot_bound_limbs(len, mod); mpz_init2(t, 4*FLINT_BITS); flint_mpz_set_ui(t, m-1); mpz_mul(t, t, t); flint_mpz_mul_ui(t, t, len); limbs2 = mpz_size(t); if (limbs1 != limbs2) { flint_printf("FAIL:\n"); flint_printf("m = %wu\n", m); flint_printf("len = %wd\n", len); flint_printf("limbs1 = %d\n", limbs1); flint_printf("limbs2 = %d\n", limbs2); gmp_printf("bound: %Zd\n", t); abort(); } mpz_clear(t); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { int iter; FLINT_TEST_INIT(state); test_field1(state); test_field2(state); for (iter = 0; iter < 100; iter++) { renf_t nf; renf_elem_t a; fmpz_t f; arb_t e; fmpz_init(f); arb_init(e); renf_randtest(nf, state, 2 + n_randint(state, 20), /* length */ 8 + n_randint(state, 2408), /* prec */ 10 + n_randint(state, 10) /* bits */ ); renf_elem_init(a, nf); renf_elem_randtest(a, state, 30 + n_randint(state, 10), nf); renf_elem_ceil(f, a, nf); arb_sub_fmpz(e, a->emb, f, 1024); if (arb_is_positive(e)) { printf("FAIL:\n"); abort(); } arb_add_ui(e, e, 1, 1024); if (arb_is_negative(e)) { printf("FAIL:\n"); abort(); } renf_elem_clear(a, nf); renf_clear(nf); fmpz_clear(f); arb_clear(e); } FLINT_TEST_CLEANUP(state); 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; }
void sample(void * arg, ulong count) { info_t * info = (info_t *) arg; slong limbs = info->limbs, i, j; int algo = info->algo; int scale = 200; FLINT_TEST_INIT(state); fmpz_t a, b, c, r; fmpz_preinvn_t inv; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_init(r); for (i = 0; i < count; i++) { fmpz_randbits(a, state, (2*limbs - 1)*FLINT_BITS); fmpz_randbits(b, state, limbs*FLINT_BITS); fmpz_preinvn_init(inv, b); prof_start(); if (algo == 1) { for (j = 0; j < scale; j++) { fmpz_fdiv_qr_preinvn(c, r, a, b, inv); } } else { for (j = 0; j < scale; j++) { fmpz_fdiv_qr(c, r, a, b); } } prof_stop(); } fmpz_preinvn_clear(inv); fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); fmpz_clear(r); flint_randclear(state); }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("is_square...."); fflush(stdout); for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a; mpz_t b; int r1, r2; fmpz_init(a); mpz_init(b); fmpz_randtest(a, state, 200); if (n_randint(state, 2) == 0) fmpz_mul(a, a, a); fmpz_get_mpz(b, a); r1 = fmpz_is_square(a); r2 = mpz_perfect_square_p(b); result = (r1 == r2); if (!result) { flint_printf("FAIL:\n"); gmp_printf("b = %Zd\n", b); abort(); } fmpz_clear(a); mpz_clear(b); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { slong m, n, rep; FLINT_TEST_INIT(state); flint_printf("add/sub/neg...."); fflush(stdout); for (rep = 0; rep < 1000 * flint_test_multiplier(); rep++) { fmpz_mat_t A; fmpz_mat_t B; fmpz_mat_t C; m = n_randint(state, 20); n = n_randint(state, 20); fmpz_mat_init(A, m, n); fmpz_mat_init(B, m, n); fmpz_mat_init(C, m, n); fmpz_mat_randtest(A, state, 100); fmpz_mat_randtest(B, state, 100); fmpz_mat_neg(C, A); fmpz_mat_add(A, A, B); fmpz_mat_sub(A, A, B); fmpz_mat_neg(A, A); if (!fmpz_mat_equal(A, C)) { flint_printf("FAIL: matrices not equal!\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(C); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mullow...."); fflush(stdout); /* Compare with truncated product of a and b */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; slong trunc; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); trunc = n_randint(state, 50); nmod_poly_randtest(b, state, trunc); nmod_poly_randtest(c, state, trunc); nmod_poly_mullow(a, b, c, trunc); nmod_poly_mul(b, b, c); nmod_poly_truncate(b, trunc); result = (nmod_poly_equal(a, b)); if (!result) { flint_printf(":\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, j, result; FLINT_TEST_INIT(state); flint_printf("get/set_coeff_si...."); fflush(stdout); for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_poly_t a; slong coeff, len; slong n1, n2; fmpz_poly_init(a); len = n_randint(state, 100) + 1; for (j = 0; j < 1000; j++) { n1 = z_randtest(state); coeff = n_randint(state, len); fmpz_poly_set_coeff_si(a, coeff, n1); n2 = fmpz_poly_get_coeff_si(a, coeff); result = (n1 == n2); if (!result) { flint_printf("FAIL: n1 = %wd, n2 = %wd, coeff = %wd, length = %wd\n", n1, n2, coeff, len); abort(); } } fmpz_poly_clear(a); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
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; }