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) { 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) { long m, n, mod, i, j, rep; flint_rand_t state; flint_randinit(state); printf("init/clear...."); fflush(stdout); for (rep = 0; rep < 100 * flint_test_multiplier(); rep++) { hmod_mat_t A; m = n_randint(state, 50); n = n_randint(state, 50); mod = hmod_randmod(state); hmod_mat_init(A, m, n, mod); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { if (A->rows[i][j] != 0UL) { printf("FAIL: entries not zero!\n"); abort(); } } } if (A->mod.n != mod) { printf("FAIL: bad modulus\n"); abort(); } hmod_mat_clear(A); } flint_randclear(state); 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("swap...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_randtest(a, state, n_randint(state, 100), 200); fmpz_poly_randtest(b, state, n_randint(state, 100), 200); fmpz_poly_set(c, b); fmpz_poly_swap(a, b); result = (fmpz_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(b), flint_printf("\n\n"); fmpz_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } 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; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mulmod_precomp...."); fflush(stdout); for (i = 0; i < 100000 * flint_test_multiplier(); i++) { mp_limb_t a, b, d, r1, r2, p1, p2, dinv; double dpre; mp_limb_t bits = n_randint(state, FLINT_D_BITS) + 1; d = n_randtest_bits(state, bits); a = n_randtest(state) % d; b = n_randtest(state) % d; dpre = n_precompute_inverse(d); r1 = n_mulmod_precomp(a, b, d, dpre); umul_ppmm(p1, p2, a, b); dinv = n_preinvert_limb(d); r2 = n_ll_mod_preinv(p1, p2, d, dinv); result = (r1 == r2); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = %wu, b = %wu, d = %wu, dinv = %f\n", a, b, d, dpre); flint_printf("r1 = %wu, r2 = %wu\n", r1, r2); abort(); } } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; ulong j; FLINT_TEST_INIT(state); flint_printf("get/set_coeff_ui...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t a; mp_limb_t n = n_randtest_not_zero(state); mp_limb_t c1 = n_randtest(state), c2; j = n_randint(state, 100); nmod_poly_init(a, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_set_coeff_ui(a, j, c1); c2 = nmod_poly_get_coeff_ui(a, j); result = (c2 == c1 % n); if (!result) { flint_printf("FAIL:\n"); flint_printf("j = %wu, c1 = %wu, c2 = %wu, n = %wu\n", j, c1, c2, a->mod.n); nmod_poly_print(a), flint_printf("\n\n"); abort(); } nmod_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("max_bits...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz *a; slong len, bits, bits2, bits3; 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); bits3 = _fmpz_vec_max_bits_ref(a, len); result = (bits >= FLINT_ABS(bits2) && bits2 == bits3); if (!result) { flint_printf("FAIL:\n"); flint_printf("bits = %wd, bits2 = %wd bits3 = %wd\n", bits, bits2, bits3); abort(); } _fmpz_vec_clear(a, len); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; double output; slong exp; FLINT_TEST_INIT(state); flint_printf("get_d_2exp...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a; fmpz_init(a); fmpz_randtest(a, state, 200); output = fmpz_get_d_2exp(&exp, a); result = (fmpz_bits(a) == exp); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = "), fmpz_print(a), flint_printf("\n"); flint_printf("output = %f\n", output); flint_printf("exp = %wd, bits = %wu\n", exp, fmpz_bits(a)); abort(); } fmpz_clear(a); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("flog...."); fflush(stdout); for (i = 0; i < 10000 * flint_test_multiplier(); i++) { mp_limb_t a = 0, b = 0, k, x; while (a < 1) a = n_randtest(state); while (b < 2) b = n_randtest(state); k = n_flog(a, b); x = n_pow(b, k); result = (x <= a && a / b < x); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = %wu\n", a); flint_printf("b = %wu\n", b); flint_printf("x = %wu\n", x); flint_printf("k = %wu\n", k); } } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { slong m, n, rep, res1, res2; FLINT_TEST_INIT(state); flint_printf("max_bits...."); fflush(stdout); for (rep = 0; rep < 100 * flint_test_multiplier(); rep++) { fmpz_mat_t A; m = n_randint(state, 20); n = n_randint(state, 20); fmpz_mat_init(A, m, n); fmpz_mat_randtest(A, state, 1 + n_randint(state, 100)); res1 = fmpz_mat_max_bits(A); res2 = _fmpz_vec_max_bits(A->entries, m*n); if (res1 != res2) { flint_printf("FAIL!\n"); abort(); } fmpz_mat_clear(A); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mod2_preinv...."); fflush(stdout); for (i = 0; i < 100000 * flint_test_multiplier(); i++) { mp_limb_t d, dinv, n, r1, r2; d = n_randtest_not_zero(state); n = n_randtest(state); dinv = n_preinvert_limb(d); r1 = n_mod2_preinv(n, d, dinv); r2 = n%d; result = (r1 == r2); if (!result) { flint_printf("FAIL:\n"); flint_printf("n = %wu, d = %wu, dinv = %wu\n", n, d, dinv); flint_printf("r1 = %wu, r2 = %wu\n", r1, r2); abort(); } } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("derivative...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_derivative(b, a); fmpq_poly_derivative(a, a); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(b) ? 0 : 2; result = (fmpq_poly_equal(a, b) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); } /* Check constants have derivative zero */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_randtest(a, state, n_randint(state, 2), 200); fmpq_poly_derivative(b, a); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; result = fmpq_poly_is_zero(b) && !cflags; if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); } /* Check (f g)' = f' g + f g' */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c, d, lhs, rhs; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_init(d); fmpq_poly_init(lhs); fmpq_poly_init(rhs); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_mul(lhs, a, b); fmpq_poly_derivative(lhs, lhs); fmpq_poly_derivative(c, a); fmpq_poly_derivative(d, b); fmpq_poly_mul(c, c, b); fmpq_poly_mul(d, a, d); fmpq_poly_add(rhs, c, d); cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1; cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2; result = fmpq_poly_equal(lhs, rhs) && !cflags; if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); fmpq_poly_clear(d); fmpq_poly_clear(lhs); fmpq_poly_clear(rhs); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int iter; FLINT_TEST_INIT(state); flint_printf("is_squarefree...."); fflush(stdout); for (iter = 0; iter < 200 * flint_test_multiplier(); iter++) { nmod_poly_t poly, Q, R, t; mp_limb_t modulus; slong i, num_factors, exp, max_exp; int v, result; modulus = n_randtest_prime(state, 0); nmod_poly_init(poly, modulus); nmod_poly_init(t, modulus); nmod_poly_init(Q, modulus); nmod_poly_init(R, modulus); nmod_poly_set_coeff_ui(poly, 0, n_randint(state, modulus)); num_factors = n_randint(state, 5); max_exp = 0; for (i = 0; i < num_factors; i++) { do { nmod_poly_randtest(t, state, n_randint(state, 10)); } while (!nmod_poly_is_irreducible(t) || (nmod_poly_length(t) < 2)); exp = n_randint(state, 4) + 1; if (n_randint(state, 2) == 0) exp = 1; nmod_poly_divrem(Q, R, poly, t); if (!nmod_poly_is_zero(R)) { nmod_poly_pow(t, t, exp); nmod_poly_mul(poly, poly, t); max_exp = FLINT_MAX(exp, max_exp); } } v = nmod_poly_is_squarefree(poly); if (v == 1) result = (max_exp <= 1 && !nmod_poly_is_zero(poly)); else result = (max_exp > 1 || nmod_poly_is_zero(poly)); if (!result) { flint_printf("FAIL: %wu, %wd, %d\n", modulus, max_exp, v); nmod_poly_print(poly); flint_printf("\n"); abort(); } nmod_poly_clear(poly); nmod_poly_clear(t); nmod_poly_clear(Q); nmod_poly_clear(R); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result = 1; FLINT_TEST_INIT(state); flint_printf("tan_series...."); fflush(stdout); /* Check atan(tan(A)) = A */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { nmod_poly_t A, tanA, B; slong n; mp_limb_t mod; mod = n_randtest_prime(state, 0); n = 1 + n_randtest(state) % 100; n = FLINT_MIN(n, mod); nmod_poly_init(A, mod); nmod_poly_init(tanA, mod); nmod_poly_init(B, mod); nmod_poly_randtest(A, state, n_randint(state, 100)); nmod_poly_set_coeff_ui(A, 0, UWORD(0)); nmod_poly_tan_series(tanA, A, n); nmod_poly_atan_series(B, tanA, n); nmod_poly_truncate(A, n); result = nmod_poly_equal(A, B); if (!result) { flint_printf("FAIL:\n"); flint_printf("n = %wd, mod = %wu\n", n, mod); flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n"); flint_printf("tan(A): "); nmod_poly_print(tanA), flint_printf("\n\n"); flint_printf("B: "); nmod_poly_print(B), flint_printf("\n\n"); abort(); } nmod_poly_clear(A); nmod_poly_clear(tanA); nmod_poly_clear(B); } /* Check aliasing */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { nmod_poly_t A, B; slong n; mp_limb_t mod; mod = n_randtest_prime(state, 0); n = n_randtest(state) % 50; n = FLINT_MIN(n, mod); nmod_poly_init(A, mod); nmod_poly_init(B, mod); nmod_poly_randtest(A, state, n_randint(state, 50)); nmod_poly_set_coeff_ui(A, 0, UWORD(0)); nmod_poly_tan_series(B, A, n); nmod_poly_tan_series(A, A, n); result = nmod_poly_equal(A, B); if (!result) { flint_printf("FAIL:\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); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mul_KS...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_KS(a, b, c, 0); nmod_poly_mul_KS(b, b, c, 0); result = (nmod_poly_equal(a, b)); if (!result) { flint_printf("FAIL:\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); } /* Check aliasing of a and c */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_KS(a, b, c, 0); nmod_poly_mul_KS(c, b, c, 0); result = (nmod_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(c), flint_printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } /* Compare with mul_classical */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a1, a2, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a1, n); nmod_poly_init(a2, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_classical(a1, b, c); nmod_poly_mul_KS(a2, b, c, 0); result = (nmod_poly_equal(a1, a2)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a1), flint_printf("\n\n"); nmod_poly_print(a2), flint_printf("\n\n"); abort(); } nmod_poly_clear(a1); nmod_poly_clear(a2); nmod_poly_clear(b); nmod_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("cdiv_q...."); fflush(stdout); for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, b, c; mpz_t d, e, f, g; fmpz_init(a); fmpz_init(b); fmpz_init(c); mpz_init(d); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); fmpz_randtest_not_zero(b, state, 200); fmpz_get_mpz(d, a); fmpz_get_mpz(e, b); fmpz_cdiv_q(c, a, b); mpz_cdiv_q(f, d, e); fmpz_get_mpz(g, c); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL\n"); gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); mpz_clear(d); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Check aliasing of a and b */ for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, c; mpz_t d, f, g; fmpz_init(a); fmpz_init(c); mpz_init(d); mpz_init(f); mpz_init(g); fmpz_randtest_not_zero(a, state, 200); fmpz_get_mpz(d, a); fmpz_cdiv_q(c, a, a); mpz_cdiv_q(f, d, d); fmpz_get_mpz(g, c); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL\n"); gmp_printf("d = %Zd, f = %Zd, g = %Zd\n", d, f, g); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(d); mpz_clear(f); mpz_clear(g); } /* Test aliasing of a and c */ for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, b; mpz_t d, e, f, g; fmpz_init(a); fmpz_init(b); mpz_init(d); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); fmpz_randtest_not_zero(b, state, 200); fmpz_get_mpz(d, a); fmpz_get_mpz(e, b); fmpz_cdiv_q(a, a, b); mpz_cdiv_q(f, d, e); fmpz_get_mpz(g, a); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL\n"); gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(b); mpz_clear(d); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Test aliasing of b and c */ for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, b; mpz_t d, e, f, g; fmpz_init(a); fmpz_init(b); mpz_init(d); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); fmpz_randtest_not_zero(b, state, 200); fmpz_get_mpz(d, a); fmpz_get_mpz(e, b); fmpz_cdiv_q(b, a, b); mpz_cdiv_q(f, d, e); fmpz_get_mpz(g, b); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL\n"); gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(b); mpz_clear(d); mpz_clear(e); mpz_clear(f); mpz_clear(g); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("divexact_si...."); fflush(stdout); for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, c; mpz_t e, f, g; slong n; fmpz_init(a); fmpz_init(c); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); n = z_randtest_not_zero(state); fmpz_mul_si(c, a, n); fmpz_get_mpz(e, c); fmpz_divexact_si(a, c, n); flint_mpz_divexact_ui(f, e, FLINT_ABS(n)); if (n < 0) mpz_neg(f, f); fmpz_get_mpz(g, a); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL:\n"); gmp_printf("n = %wd, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Test aliasing of a and c */ for (i = 0; i < 10000 * flint_test_multiplier(); i++) { fmpz_t a, c; mpz_t d, f, g; slong n; fmpz_init(a); fmpz_init(c); mpz_init(d); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); n = z_randtest_not_zero(state); fmpz_mul_si(c, a, n); fmpz_get_mpz(d, c); fmpz_divexact_si(c, c, n); flint_mpz_divexact_ui(f, d, FLINT_ABS(n)); if (n < 0) mpz_neg(f, f); fmpz_get_mpz(g, c); result = (mpz_cmp(f, g) == 0); if (!result) { flint_printf("FAIL;\n"); gmp_printf("d = %Zd, n = %wd, f = %Zd, g = %Zd\n", d, n, f, g); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(d); mpz_clear(f); mpz_clear(g); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("evaluate_fmpz...."); fflush(stdout); /* Check that (f+g)(a) = f(a) + g(a) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a; fmpq_poly_t f, g, h; fmpq_t x, y; fmpq_init(x); fmpq_init(y); fmpz_init(a); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(f, state, n_randint(state, 100), 200); fmpq_poly_randtest(g, state, n_randint(state, 100), 200); fmpz_randtest(a, state, n_randint(state, 100)); fmpq_poly_evaluate_fmpz(x, f, a); fmpq_poly_evaluate_fmpz(y, g, a); fmpq_add(x, x, y); fmpq_poly_add(h, f, g); fmpq_poly_evaluate_fmpz(y, h, a); result = (fmpq_equal(x, y)); if (!result) { flint_printf("FAIL:\n"); flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n"); flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n"); flint_printf("a = "), fmpz_print(a), flint_printf("\n"); flint_printf("f(a) + g(a) = "), fmpq_print(x), flint_printf("\n\n"); flint_printf("(f + g)(a) = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(a); fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Check that (f*g)(a) = f(a) * g(a) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a; fmpq_poly_t f, g; fmpq_t x, y; fmpq_init(x); fmpq_init(y); fmpz_init(a); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_randtest(f, state, n_randint(state, 100), 200); fmpq_poly_randtest(g, state, n_randint(state, 100), 200); fmpz_randtest(a, state, n_randint(state, 100)); fmpq_poly_evaluate_fmpz(x, f, a); fmpq_poly_evaluate_fmpz(y, g, a); fmpq_mul(x, x, y); fmpq_poly_mul(f, f, g); fmpq_poly_evaluate_fmpz(y, f, a); result = (fmpq_equal(x, y)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(a), flint_printf("\n\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(a); fmpq_poly_clear(f); fmpq_poly_clear(g); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("scalar_addmul_fmpz...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; fmpz_t x; fmpz_init(x); fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_randtest(x, state, n_randint(state, 100)); fmpz_poly_randtest(a, state, n_randint(state, 100), 200); fmpz_poly_set(b, a); fmpz_poly_set(c, a); fmpz_poly_scalar_addmul_fmpz(b, a, x); fmpz_poly_scalar_addmul_fmpz(a, a, x); result = (fmpz_poly_equal(a, b)); if (!result) { flint_printf("FAIL (1):\n"); flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n"); flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n"); flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n"); flint_printf("x = "), fmpz_print(x), flint_printf("\n\n"); abort(); } fmpz_clear(x); fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } /* Check that b += x*a is the same as c = b + x*a */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; fmpz_t x; fmpz_init(x); fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_randtest(x, state, n_randint(state, 100)); fmpz_poly_randtest(a, state, n_randint(state, 100), 200); fmpz_poly_randtest(b, state, n_randint(state, 100), 200); fmpz_poly_scalar_mul_fmpz(c, a, x); fmpz_poly_add(c, b, c); fmpz_poly_scalar_addmul_fmpz(b, a, x); result = (fmpz_poly_equal(b, c)); if (!result) { flint_printf("FAIL (2):\n"); flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n"); flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n"); flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n"); flint_printf("x = "), fmpz_print(x), flint_printf("\n\n"); abort(); } fmpz_clear(x); fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("multi_CRT_ui...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { slong bits, prime_bits, rows, cols, num_primes, j; fmpz_t mod; fmpz_mat_t A, B, C; nmod_mat_t Amod[1000]; mp_limb_t primes[1000]; bits = n_randint(state, 500) + 1; rows = n_randint(state, 10); cols = n_randint(state, 10); prime_bits = 1 + n_randint(state, FLINT_BITS - 1); fmpz_mat_init(A, rows, cols); fmpz_mat_init(B, rows, cols); fmpz_mat_init(C, rows, cols); fmpz_mat_randtest(A, state, bits); fmpz_init(mod); num_primes = 0; primes[0] = n_nextprime(UWORD(1) << prime_bits, 0); fmpz_set_ui(mod, primes[0]); /* + 1 for sign */ while (fmpz_bits(mod) <= bits + 1) { primes[num_primes + 1] = n_nextprime(primes[num_primes], 0); fmpz_mul_ui(mod, mod, primes[num_primes + 1]); num_primes++; } num_primes++; for (j = 0; j < num_primes; j++) nmod_mat_init(Amod[j], rows, cols, primes[j]); fmpz_mat_multi_mod_ui(Amod, num_primes, A); fmpz_mat_multi_CRT_ui(B, Amod, num_primes, 1); if (!fmpz_mat_equal(B, A)) { flint_printf("FAIL!\n"); flint_printf("primes: "); for (j = 0; j < num_primes; j++) flint_printf("%wu ", primes[j]); flint_printf("\nA: \n"); fmpz_mat_print_pretty(A); flint_printf("\nB: \n"); fmpz_mat_print_pretty(B); flint_printf("\n"); abort(); } for (j = 0; j < num_primes; j++) nmod_mat_clear(Amod[j]); fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(C); fmpz_clear(mod); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mul_karatsuba...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_randtest(b, state, n_randint(state, 50), 200); fmpz_poly_randtest(c, state, n_randint(state, 50), 200); fmpz_poly_mul_karatsuba(a, b, c); fmpz_poly_mul_karatsuba(b, b, c); result = (fmpz_poly_equal(a, b)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(b), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } /* Check aliasing of a and c */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_randtest(b, state, n_randint(state, 50), 200); fmpz_poly_randtest(c, state, n_randint(state, 50), 200); fmpz_poly_mul_karatsuba(a, b, c); fmpz_poly_mul_karatsuba(c, b, c); result = (fmpz_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } /* Compare with mul_classical */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c, d; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_init(d); fmpz_poly_randtest(b, state, n_randint(state, 50), 200); fmpz_poly_randtest(c, state, n_randint(state, 50), 200); fmpz_poly_mul_karatsuba(a, b, c); fmpz_poly_mul_classical(d, b, c); result = (fmpz_poly_equal(a, d)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(d), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); fmpz_poly_clear(d); } /* Check _fmpz_poly_mul_karatsuba directly */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { slong len1, len2; fmpz_poly_t a, b, out1, out2; len1 = n_randint(state, 100) + 1; len2 = n_randint(state, 100) + 1; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(out1); fmpz_poly_init(out2); fmpz_poly_randtest(a, state, len1, 200); fmpz_poly_randtest(b, state, len2, 200); fmpz_poly_mul_karatsuba(out1, a, b); fmpz_poly_fit_length(a, a->alloc + n_randint(state, 10)); fmpz_poly_fit_length(b, b->alloc + n_randint(state, 10)); a->length = a->alloc; b->length = b->alloc; fmpz_poly_fit_length(out2, a->length + b->length - 1); if (a->length >= b->length) _fmpz_poly_mul_karatsuba(out2->coeffs, a->coeffs, a->length, b->coeffs, b->length); else _fmpz_poly_mul_karatsuba(out2->coeffs, b->coeffs, b->length, a->coeffs, a->length); _fmpz_poly_set_length(out2, a->length + b->length - 1); _fmpz_poly_normalise(out2); result = (fmpz_poly_equal(out1, out2)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(out1), flint_printf("\n\n"); fmpz_poly_print(out2), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(out1); fmpz_poly_clear(out2); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { fmpz_mat_t A, X, B, AX; fmpz_t den; slong i, m, n, r; int success; FLINT_TEST_INIT(state); flint_printf("solve_cramer...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { m = n_randint(state, 4); n = n_randint(state, 10); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_init(den); fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_cramer(X, den, A, B); fmpz_mat_mul(AX, A, X); fmpz_mat_scalar_divexact_fmpz(AX, AX, den); if (!fmpz_mat_equal(AX, B) || !success) { flint_printf("FAIL:\n"); flint_printf("AX != B!\n"); flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n"); flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n"); flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n"); flint_printf("den(X) = "), fmpz_print(den), flint_printf("\n"); flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_clear(den); } /* Test singular systems */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { m = 1 + n_randint(state, 3); n = 1 + n_randint(state, 10); r = n_randint(state, m); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_init(den); fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_cramer(X, den, A, B); if (!fmpz_is_zero(den) || success) { flint_printf("FAIL:\n"); flint_printf("singular system gave nonzero determinant\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_clear(den); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { fmpz_mat_t A, X, B, AX, AXm, Bm; fmpz_t mod; slong i, m, n, r; int success; FLINT_TEST_INIT(state); flint_printf("solve_dixon...."); fflush(stdout); for (i = 0; i < 100 * flint_test_multiplier(); i++) { m = n_randint(state, 20); n = n_randint(state, 20); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(Bm, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_mat_init(AXm, m, n); fmpz_init(mod); fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_dixon(X, mod, A, B); fmpz_mat_set(AXm, X); fmpz_mat_mul(AX, A, AXm); fmpz_mat_scalar_mod_fmpz(AXm, AX, mod); fmpz_mat_scalar_mod_fmpz(Bm, B, mod); if (!fmpz_mat_equal(AXm, Bm) || !success) { flint_printf("FAIL:\n"); flint_printf("AX != B!\n"); flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n"); flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n"); flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n"); flint_printf("mod = "), fmpz_print(mod), flint_printf("\n"); flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(Bm); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_mat_clear(AXm); fmpz_clear(mod); } /* Test singular systems */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { m = 1 + n_randint(state, 10); n = 1 + n_randint(state, 10); r = n_randint(state, m); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_init(mod); fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); if (fmpz_mat_solve_dixon(X, mod, A, B) != 0) { flint_printf("FAIL:\n"); flint_printf("singular system, returned nonzero\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_clear(mod); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("inv_series_newton...."); fflush(stdout); /* Check Q^{-1} * Q is congruent 1 mod t^n */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c, one; slong n = n_randint(state, 80) + 1; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_init(one); fmpz_poly_randtest_not_zero(a, state, n_randint(state, 80) + 1, 100); fmpz_poly_set_coeff_si(a, 0, n_randint(state, 2) ? 1 : -1); fmpz_poly_set_ui(one, 1); fmpz_poly_inv_series_newton(b, a, n); fmpz_poly_mullow(c, a, b, n); result = (fmpz_poly_equal(c, one)); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n"); flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n"); flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); fmpz_poly_clear(one); } /* Verify bug fix for the case Q = -1 mod (x) */ { fmpz_poly_t a, b, c, one; slong n = 1; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_init(one); fmpz_poly_set_si(a, -1); fmpz_poly_set_ui(one, 1); fmpz_poly_inv_series_newton(b, a, n); fmpz_poly_mullow(c, a, b, n); result = (fmpz_poly_equal(c, one)); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n"); flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n"); flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); fmpz_poly_clear(one); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("sqrlow_KS...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b; slong len, trunc; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_randtest(b, state, n_randint(state, 50), 200); len = 2 * b->length - 1; trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length); fmpz_poly_sqrlow_KS(a, b, trunc); fmpz_poly_sqrlow_KS(b, b, trunc); result = (fmpz_poly_equal(a, b)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(b), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); } /* Compare with sqr_KS */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, c; slong len, trunc; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(c); fmpz_poly_randtest(b, state, n_randint(state, 50), 200); len = 2 * b->length - 1; trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length - 1); fmpz_poly_sqr_KS(a, b); fmpz_poly_truncate(a, trunc); fmpz_poly_sqrlow_KS(c, b, trunc); result = (fmpz_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(b), flint_printf("\n\n"); fmpz_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("compose_horner...."); fflush(stdout); /* Check aliasing of the first argument */ for (i = 0; i < 8 * flint_test_multiplier(); i++) { fmpz_poly_t f, g, h; fmpz_poly_init(f); fmpz_poly_init(g); fmpz_poly_init(h); fmpz_poly_randtest(g, state, n_randint(state, 40), 80); fmpz_poly_randtest(h, state, n_randint(state, 20), 50); fmpz_poly_compose_horner(f, g, h); fmpz_poly_compose_horner(g, g, h); result = (fmpz_poly_equal(f, g)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(f), flint_printf("\n\n"); fmpz_poly_print(g), flint_printf("\n\n"); abort(); } fmpz_poly_clear(f); fmpz_poly_clear(g); fmpz_poly_clear(h); } /* Check aliasing of the second argument */ for (i = 0; i < 8 * flint_test_multiplier(); i++) { fmpz_poly_t f, g, h; fmpz_poly_init(f); fmpz_poly_init(g); fmpz_poly_init(h); fmpz_poly_randtest(g, state, n_randint(state, 40), 80); fmpz_poly_randtest(h, state, n_randint(state, 20), 50); fmpz_poly_compose_horner(f, g, h); fmpz_poly_compose_horner(h, g, h); result = (fmpz_poly_equal(f, h)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(f), flint_printf("\n\n"); fmpz_poly_print(h), flint_printf("\n\n"); abort(); } fmpz_poly_clear(f); fmpz_poly_clear(g); fmpz_poly_clear(h); } /* Compare with the default method */ for (i = 0; i < 8 * flint_test_multiplier(); i++) { fmpz_poly_t f1, f2, g, h; fmpz_poly_init(f1); fmpz_poly_init(f2); fmpz_poly_init(g); fmpz_poly_init(h); fmpz_poly_randtest(g, state, n_randint(state, 40), 80); fmpz_poly_randtest(h, state, n_randint(state, 20), 50); fmpz_poly_compose_horner(f1, g, h); fmpz_poly_compose(f2, g, h); result = (fmpz_poly_equal(f1, f2)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(f1), flint_printf("\n\n"); fmpz_poly_print(f2), flint_printf("\n\n"); abort(); } fmpz_poly_clear(f1); fmpz_poly_clear(f2); fmpz_poly_clear(g); fmpz_poly_clear(h); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("sqrt_series...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 50 * flint_test_multiplier(); i++) { fmpq_poly_t a, b; slong n = n_randint(state, 50) + 1; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_randtest_not_zero(a, state, n_randint(state, 50) + 1, 50); fmpq_poly_set_coeff_ui(a, 0, UWORD(1)); fmpq_poly_canonicalise(a); fmpq_poly_sqrt_series(b, a, n); fmpq_poly_sqrt_series(a, a, n); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(b) ? 0 : 2; result = (fmpq_poly_equal(a, b) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); } /* Check sqrt(a)^2 = a */ for (i = 0; i < 50 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c; slong n = n_randint(state, 80) + 1; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest_not_zero(a, state, n_randint(state, 80) + 1, 80); fmpq_poly_set_coeff_ui(a, 0, UWORD(1)); fmpq_poly_sqrt_series(b, a, n); fmpq_poly_mullow(c, b, b, n); fmpq_poly_truncate(a, n); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; result = (fmpq_poly_equal(c, a) && !cflags); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = "), fmpq_poly_debug(a), flint_printf("\n\n"); flint_printf("b = "), fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("c = "), fmpq_poly_debug(c), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("scalar_div_fmpq...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b; fmpq_t z; fmpq_init(z); fmpq_randtest_not_zero(z, state, 100); fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_scalar_div_fmpq(b, a, z); fmpq_poly_scalar_div_fmpq(a, a, z); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(b) ? 0 : 2; result = (fmpq_poly_equal(a, b) && !cflags); if (!result) { flint_printf("FAIL (aliasing):\n\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); fmpq_print(z), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(b); } /* Check that (a / n1) / n2 == a / (n1 * n2) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, lhs, rhs; fmpq_t z1, z2, z; fmpq_init(z1); fmpq_init(z2); fmpq_init(z); fmpq_randtest_not_zero(z1, state, 100); fmpq_randtest_not_zero(z2, state, 100); fmpq_mul(z, z1, z2); fmpq_poly_init(a); fmpq_poly_init(lhs); fmpq_poly_init(rhs); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_scalar_div_fmpq(lhs, a, z1); fmpq_poly_scalar_div_fmpq(lhs, lhs, z2); fmpq_poly_scalar_div_fmpq(rhs, a, z); cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1; cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2; result = (fmpq_poly_equal(lhs, rhs) && !cflags); if (!result) { flint_printf("FAIL (a / n1 / n2):\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_print(z1), flint_printf("\n\n"); fmpq_print(z2), flint_printf("\n\n"); fmpq_print(z), flint_printf("\n\n"); fmpq_poly_debug(lhs), flint_printf("\n\n"); fmpq_poly_debug(rhs), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z1); fmpq_clear(z2); fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(lhs); fmpq_poly_clear(rhs); } /* Check that (a + b) / n == a/n + b/n */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, lhs, rhs; fmpq_t z; fmpq_init(z); fmpq_randtest_not_zero(z, state, 100); fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(lhs); fmpq_poly_init(rhs); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_scalar_div_fmpq(lhs, a, z); fmpq_poly_scalar_div_fmpq(rhs, b, z); fmpq_poly_add(rhs, lhs, rhs); fmpq_poly_add(lhs, a, b); fmpq_poly_scalar_div_fmpq(lhs, lhs, z); cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1; cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2; result = (fmpq_poly_equal(lhs, rhs) && !cflags); if (!result) { flint_printf("FAIL ((a + b) / n):\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); fmpq_print(z), flint_printf("\n\n"); fmpq_poly_debug(lhs), flint_printf("\n\n"); fmpq_poly_debug(rhs), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(lhs); fmpq_poly_clear(rhs); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }