/* hack: avoid overflow since exp currently uses mpfr */ void fmpq_poly_randtest_small(fmpq_poly_t A, flint_rand_t state, long len, long bits) { fmpq_poly_randtest(A, state, len, bits); if (A->length > 0) { bits = _fmpz_vec_max_bits(A->coeffs, A->length); bits = FLINT_ABS(bits); fmpz_mul_2exp(A->den, A->den, bits); _fmpq_poly_normalise(A); } }
void fmpq_poly_randtest_not_zero(fmpq_poly_t f, flint_rand_t state, long len, mp_bitcnt_t bits) { if ((bits == 0) | (len == 0)) { printf("Exception: 0 passed to fmpz_poly_randtest_not_zero\n"); abort(); } fmpq_poly_randtest(f, state, len, bits); if (f->length == 0) fmpq_poly_set_ui(f, 1); }
int main() { long iter; flint_rand_t state; printf("divrem...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { long m, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, Q, R; arb_poly_t a, b, q, r; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(Q); fmpq_poly_init(R); arb_poly_init(a); arb_poly_init(b); arb_poly_init(q); arb_poly_init(r); fmpq_poly_randtest(A, state, m, qbits1); fmpq_poly_randtest_not_zero(B, state, n, qbits2); fmpq_poly_divrem(Q, R, A, B); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_divrem(q, r, a, b, rbits3); if (!arb_poly_contains_fmpq_poly(q, Q) || !arb_poly_contains_fmpq_poly(r, R)) { printf("FAIL\n\n"); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("Q = "); fmpq_poly_print(Q); printf("\n\n"); printf("R = "); fmpq_poly_print(R); printf("\n\n"); printf("a = "); arb_poly_printd(a, 15); printf("\n\n"); printf("b = "); arb_poly_printd(b, 15); printf("\n\n"); printf("q = "); arb_poly_printd(q, 15); printf("\n\n"); printf("r = "); arb_poly_printd(r, 15); printf("\n\n"); abort(); } arb_poly_divrem(a, r, a, b, rbits3); if (!arb_poly_equal(a, q)) { printf("FAIL (aliasing q, a)\n\n"); } arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_divrem(b, r, a, b, rbits3); if (!arb_poly_equal(b, q)) { printf("FAIL (aliasing q, b)\n\n"); abort(); } arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_divrem(q, a, a, b, rbits3); if (!arb_poly_equal(a, r)) { printf("FAIL (aliasing r, a)\n\n"); abort(); } arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_divrem(q, b, a, b, rbits3); if (!arb_poly_equal(b, r)) { printf("FAIL (aliasing r, b)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(Q); fmpq_poly_clear(R); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(q); arb_poly_clear(r); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("mullow_transpose...."); fflush(stdout); flint_randinit(state); /* compare with fmpq_poly */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3, trunc; fmpq_poly_t A, B, C; acb_poly_t a, b, c, d; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); trunc = n_randint(state, 10); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); acb_poly_init(d); fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2); fmpq_poly_mullow(C, A, B, trunc); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_set_fmpq_poly(b, B, rbits2); acb_poly_mullow_transpose(c, a, b, trunc, rbits3); if (!acb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits3 = %wd\n", rbits3); flint_printf("trunc = %wd\n", trunc); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } acb_poly_set(d, a); acb_poly_mullow_transpose(d, d, b, trunc, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); abort(); } acb_poly_set(d, b); acb_poly_mullow_transpose(d, a, d, trunc, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); abort(); } /* test squaring */ acb_poly_set(b, a); acb_poly_mullow_transpose(c, a, b, trunc, rbits3); acb_poly_mullow_transpose(d, a, a, trunc, rbits3); if (!acb_poly_overlaps(c, d)) /* not guaranteed to be identical */ { flint_printf("FAIL (squaring)\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } acb_poly_mullow_transpose(a, a, a, trunc, rbits3); if (!acb_poly_equal(d, a)) { flint_printf("FAIL (aliasing, squaring)\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); acb_poly_clear(d); } /* compare with classical */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong bits, trunc; acb_poly_t a, b, ab, ab2; bits = 2 + n_randint(state, 200); trunc = n_randint(state, 10); acb_poly_init(a); acb_poly_init(b); acb_poly_init(ab); acb_poly_init(ab2); acb_poly_randtest(a, state, 1 + n_randint(state, 10), bits, 5); acb_poly_randtest(b, state, 1 + n_randint(state, 10), bits, 5); acb_poly_mullow_classical(ab, a, b, trunc, bits); acb_poly_mullow_transpose(ab2, a, b, trunc, bits); if (!acb_poly_overlaps(ab, ab2)) { flint_printf("FAIL\n\n"); flint_printf("bits = %wd\n", bits); flint_printf("trunc = %wd\n", trunc); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("ab = "); acb_poly_printd(ab, 15); flint_printf("\n\n"); flint_printf("ab2 = "); acb_poly_printd(ab2, 15); flint_printf("\n\n"); abort(); } acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(ab); acb_poly_clear(ab2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("evaluate_fmpq...."); fflush(stdout); flint_randinit(state); /* Check aliasing */ for (i = 0; i < 1000; i++) { fmpz_t a, b; fmpq_t x, y; fmpq_poly_t f; fmpz_init(a); fmpz_init(b); fmpq_init(x); fmpq_init(y); fmpq_poly_init(f); fmpq_poly_randtest(f, state, n_randint(state, 80), 100); fmpz_randtest(a, state, 80); fmpz_randtest_not_zero(b, state, 80); fmpz_set(fmpq_numref(x), a); fmpz_set(fmpq_denref(x), a); fmpq_canonicalise(x); fmpq_poly_evaluate_fmpq(y, f, x); fmpq_poly_evaluate_fmpq(x, f, x); result = (fmpq_equal(x, y)); if (!result) { printf("FAIL:\n"); fmpz_print(a), printf("\n\n"); fmpz_print(b), printf("\n\n"); fmpq_poly_debug(f), printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpq_clear(x); fmpq_clear(y); fmpq_poly_clear(f); } /* Check that (f+g)(a) = f(a) + g(a) */ for (i = 0; i < 1000; i++) { fmpz_t a, b; fmpq_t x, y, z; fmpq_poly_t f, g; fmpz_init(a); fmpz_init(b); fmpq_init(x); fmpq_init(y); fmpq_init(z); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_randtest(f, state, n_randint(state, 80), 100); fmpq_poly_randtest(g, state, n_randint(state, 80), 100); fmpz_randtest(a, state, 80); fmpz_randtest_not_zero(b, state, 80); fmpz_set(fmpq_numref(x), a); fmpz_set(fmpq_denref(x), a); fmpq_canonicalise(x); fmpq_poly_evaluate_fmpq(y, f, x); fmpq_poly_evaluate_fmpq(z, g, x); fmpq_add(y, y, z); fmpq_poly_add(f, f, g); fmpq_poly_evaluate_fmpq(z, f, x); result = (fmpq_equal(y, z)); if (!result) { printf("FAIL:\n"); fmpz_print(a), printf("\n\n"); fmpz_print(b), printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_poly_clear(f); fmpq_poly_clear(g); } /* Check that (f*g)(a) = f(a) * g(a) */ for (i = 0; i < 1000; i++) { fmpz_t a, b; fmpq_t x, y, z; fmpq_poly_t f, g; fmpz_init(a); fmpz_init(b); fmpq_init(x); fmpq_init(y); fmpq_init(z); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_randtest(f, state, n_randint(state, 50), 80); fmpq_poly_randtest(g, state, n_randint(state, 50), 80); fmpz_randtest(a, state, 80); fmpz_randtest_not_zero(b, state, 80); fmpz_set(fmpq_numref(x), a); fmpz_set(fmpq_denref(x), a); fmpq_canonicalise(x); fmpq_poly_evaluate_fmpq(y, f, x); fmpq_poly_evaluate_fmpq(z, g, x); fmpq_mul(y, y, z); fmpq_poly_mul(f, f, g); fmpq_poly_evaluate_fmpq(z, f, x); result = (fmpq_equal(y, z)); if (!result) { printf("FAIL:\n"); fmpz_print(a), printf("\n\n"); fmpz_print(b), printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_poly_clear(f); fmpq_poly_clear(g); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("evaluate_vec_fast...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong i, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t F; fmpq * X, * Y; arb_poly_t f; arb_ptr x, y; qbits1 = 2 + n_randint(state, 100); qbits2 = 2 + n_randint(state, 100); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); n = n_randint(state, 10); fmpq_poly_init(F); X = _fmpq_vec_init(n); Y = _fmpq_vec_init(n); arb_poly_init(f); x = _arb_vec_init(n); y = _arb_vec_init(n); fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1); for (i = 0; i < n; i++) fmpq_randtest(X + i, state, qbits2); for (i = 0; i < n; i++) fmpq_poly_evaluate_fmpq(Y + i, F, X + i); arb_poly_set_fmpq_poly(f, F, rbits1); for (i = 0; i < n; i++) arb_set_fmpq(x + i, X + i, rbits2); arb_poly_evaluate_vec_fast(y, f, x, n, rbits3); for (i = 0; i < n; i++) { if (!arb_contains_fmpq(y + i, Y + i)) { flint_printf("FAIL (%wd of %wd)\n\n", i, n); flint_printf("F = "); fmpq_poly_print(F); flint_printf("\n\n"); flint_printf("X = "); fmpq_print(X + i); flint_printf("\n\n"); flint_printf("Y = "); fmpq_print(Y + i); flint_printf("\n\n"); flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("x = "); arb_printd(x + i, 15); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y + i, 15); flint_printf("\n\n"); abort(); } } fmpq_poly_clear(F); _fmpq_vec_clear(X, n); _fmpq_vec_clear(Y, n); arb_poly_clear(f); _arb_vec_clear(x, n); _arb_vec_clear(y, n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("interpolate_fast...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { long i, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t P; arb_poly_t R, S; fmpq_t t, u; arb_ptr xs, ys; fmpq_poly_init(P); arb_poly_init(R); arb_poly_init(S); fmpq_init(t); fmpq_init(u); qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 5); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_randtest(P, state, 1 + n_randint(state, 20), qbits1); n = P->length; xs = _arb_vec_init(n); ys = _arb_vec_init(n); arb_poly_set_fmpq_poly(R, P, rbits1); if (n > 0) { fmpq_randtest(t, state, qbits2); arb_set_fmpq(xs, t, rbits2); for (i = 1; i < n; i++) { fmpq_randtest_not_zero(u, state, qbits2); fmpq_abs(u, u); fmpq_add(t, t, u); arb_set_fmpq(xs + i, t, rbits2); } } for (i = 0; i < n; i++) arb_poly_evaluate(ys + i, R, xs + i, rbits2); arb_poly_interpolate_fast(S, xs, ys, n, rbits3); if (!arb_poly_contains_fmpq_poly(S, P)) { printf("FAIL:\n"); printf("P = "); fmpq_poly_print(P); printf("\n\n"); printf("R = "); arb_poly_printd(R, 15); printf("\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); abort(); } fmpq_poly_clear(P); arb_poly_clear(R); arb_poly_clear(S); fmpq_clear(t); fmpq_clear(u); _arb_vec_clear(xs, n); _arb_vec_clear(ys, n); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("sub...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { long qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, C; fmprb_poly_t a, b, c; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); fmprb_poly_init(a); fmprb_poly_init(b); fmprb_poly_init(c); fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2); fmpq_poly_sub(C, A, B); fmprb_poly_set_fmpq_poly(a, A, rbits1); fmprb_poly_set_fmpq_poly(b, B, rbits2); fmprb_poly_sub(c, a, b, rbits3); if (!fmprb_poly_contains_fmpq_poly(c, C)) { printf("FAIL\n\n"); printf("bits3 = %ld\n", rbits3); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("C = "); fmpq_poly_print(C); printf("\n\n"); printf("a = "); fmprb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmprb_poly_printd(b, 15); printf("\n\n"); printf("c = "); fmprb_poly_printd(c, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); fmprb_poly_clear(a); fmprb_poly_clear(b); fmprb_poly_clear(c); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("revert_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { slong qbits1, rbits1, rbits2, n; fmpq_poly_t A, B; acb_poly_t a, b, c; qbits1 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); n = 2 + n_randint(state, 25); fmpq_poly_init(A); fmpq_poly_init(B); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); do { fmpq_poly_randtest(A, state, 1 + n_randint(state, 25), qbits1); fmpq_poly_set_coeff_ui(A, 0, 0); } while (A->length < 2 || fmpz_is_zero(A->coeffs + 1)); fmpq_poly_revert_series(B, A, n); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_revert_series(b, a, n, rbits2); if (!acb_poly_contains_fmpq_poly(b, B)) { flint_printf("FAIL\n\n"); flint_printf("n = %wd, bits2 = %wd\n", n, rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); abort(); } acb_poly_set(c, a); acb_poly_revert_series(c, c, n, rbits2); if (!acb_poly_equal(c, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("sin_cos_series_tangent...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2; fmpq_poly_t A, B; fmprb_poly_t a, b, c, d, e; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); fmpq_poly_init(A); fmpq_poly_init(B); fmprb_poly_init(a); fmprb_poly_init(b); fmprb_poly_init(c); fmprb_poly_init(d); fmprb_poly_init(e); fmpq_poly_randtest(A, state, m, qbits); fmprb_poly_set_fmpq_poly(a, A, rbits1); fmprb_poly_sin_cos_series_tangent(b, c, a, n, rbits2); /* Check sin(x)^2 + cos(x)^2 = 1 */ fmprb_poly_mullow(d, b, b, n, rbits2); fmprb_poly_mullow(e, c, c, n, rbits2); fmprb_poly_add(d, d, e, rbits2); fmpq_poly_one(B); if (!fmprb_poly_contains_fmpq_poly(d, B)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("a = "); fmprb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmprb_poly_printd(b, 15); printf("\n\n"); printf("c = "); fmprb_poly_printd(c, 15); printf("\n\n"); printf("d = "); fmprb_poly_printd(d, 15); printf("\n\n"); abort(); } fmprb_poly_set(d, a); fmprb_poly_sin_cos_series_tangent(d, c, d, n, rbits2); if (!fmprb_poly_equal(b, d)) { printf("FAIL (aliasing 1)\n\n"); abort(); } fmprb_poly_set(d, a); fmprb_poly_sin_cos_series_tangent(b, d, d, n, rbits2); if (!fmprb_poly_equal(c, d)) { printf("FAIL (aliasing 2)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmprb_poly_clear(a); fmprb_poly_clear(b); fmprb_poly_clear(c); fmprb_poly_clear(d); fmprb_poly_clear(e); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("mul...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, C; arb_poly_t a, b, c, d; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2); fmpq_poly_mul(C, A, B); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_mul(c, a, b, rbits3); if (!arb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits3 = %wd\n", rbits3); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } arb_poly_set(d, a); arb_poly_mul(d, d, b, rbits3); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); abort(); } arb_poly_set(d, b); arb_poly_mul(d, a, d, rbits3); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); abort(); } /* test squaring */ arb_poly_set(b, a); arb_poly_mul(c, a, b, rbits3); arb_poly_mul(d, a, a, rbits3); if (!arb_poly_overlaps(c, d)) /* not guaranteed to be identical */ { flint_printf("FAIL (squaring)\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } arb_poly_mul(a, a, a, rbits3); if (!arb_poly_equal(d, a)) { flint_printf("FAIL (aliasing, squaring)\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("acos_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong m, n, qbits, rbits1, rbits2; fmpq_poly_t A; arb_poly_t a, b, c, d; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); fmpq_poly_init(A); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, m, qbits); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_randtest(b, state, 1 + n_randint(state, 30), rbits1, 5); arb_poly_acos_series(b, a, n, rbits2); /* Check cos(acos(x)) = x */ arb_poly_sin_cos_series_basecase(d, c, b, n, rbits2, 0); fmpq_poly_truncate(A, n); if (!arb_poly_contains_fmpq_poly(c, A)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } arb_poly_acos_series(a, a, n, rbits2); if (!arb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, j, n = 1000, result; flint_rand_t state; FILE *in, *out; int fd[2]; pid_t childpid; printf("print/ read...."); fflush(stdout); flint_randinit(state); /* Randomise n polynomials, write to and read from a pipe */ { fmpq_poly_t *a; a = flint_malloc(n * sizeof(fmpq_poly_t)); for (i = 0; i < n; i++) { fmpq_poly_init(a[i]); fmpq_poly_randtest(a[i], state, 100, 100); } if (pipe(fd)) { printf("FAIL:\n"); printf("Failed to set-up the pipe.\n"); abort(); } if((childpid = fork()) == -1) { printf("FAIL:\n"); printf("Failed to fork the process.\n"); abort(); } if(childpid == 0) /* Child process */ { int r; close(fd[0]); out = fdopen(fd[1], "w"); if (out == NULL) { printf("FAIL:\n"); printf("Could not open output file at the pipe.\n"); abort(); } for (j = 0; j < n; j++) { r = fmpq_poly_fprint(out, a[j]); if ((j < n - 1) && (r > 0)) r = fprintf(out, "\n"); if (r <= 0) { printf("FAIL:\n"); printf("Write error.\n"); abort(); } } fclose(out); exit(0); } else /* Parent process */ { int r; fmpq_poly_t t; close(fd[1]); in = fdopen(fd[0], "r"); if (in == NULL) { printf("FAIL:\n"); printf("Could not open input file at the pipe.\n"); abort(); } fmpq_poly_init(t); i = 0; while (!feof(in)) { r = fmpq_poly_fread(in, t); if (r <= 0) { printf("FAIL:\n"); printf("Read error.\n"); abort(); } result = fmpq_poly_equal(t, a[i]); if (!result) { printf("FAIL:\n"); printf("a[i] = "), fmpq_poly_debug(a[i]), printf("\n"); printf("t = "), fmpq_poly_debug(t), printf("\n"); abort(); } ++i; } fmpq_poly_clear(t); fclose(in); } if (i != n) { printf("FAIL:\n"); printf("Only %d out of %d objects were processed.\n", i, n); abort(); } for (i = 0; i < n; i++) fmpq_poly_clear(a[i]); flint_free(a); } /* Write bad data to a pipe and read it */ { char str[5] = {'b', 'l', 'a', 'h', '\0'}; if (pipe(fd)) { printf("FAIL:\n"); printf("Failed to set-up the pipe.\n"); abort(); } if((childpid = fork()) == -1) { printf("FAIL:\n"); printf("Failed to fork the process.\n"); abort(); } if(childpid == 0) /* Child process */ { int r; close(fd[0]); out = fdopen(fd[1], "w"); if (out == NULL) { printf("FAIL:\n"); printf("Could not open output file at the pipe.\n"); abort(); } r = fprintf(out, "blah"); if (r <= 0) { printf("FAIL:\n"); printf("Write error.\n"); abort(); } fclose(out); exit(0); } else /* Parent process */ { int r; fmpq_poly_t t; close(fd[1]); in = fdopen(fd[0], "r"); if (in == NULL) { printf("FAIL:\n"); printf("Could not open input file at the pipe.\n"); abort(); } fmpq_poly_init(t); i = 0; while (!feof(in)) { r = fmpq_poly_fread(in, t); if (r > 0) { printf("FAIL:\n"); printf("r = %d\n", r); abort(); } ++i; } fmpq_poly_clear(t); fclose(in); } /* For {'b','l','a','h','\0'} we expect 5 reads */ if (i != 5) { printf("FAIL:\n"); printf("Carried out %d reads, but \"%s\" has only 4 characters.\n", i, str); abort(); } } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("compose...."); fflush(stdout); /* Check aliasing of the first argument */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(g, state, n_randint(state, 50), 100); fmpq_poly_randtest(h, state, n_randint(state, 20), 50); fmpq_poly_compose(f, g, h); fmpq_poly_compose(g, g, h); cflags |= fmpq_poly_is_canonical(f) ? 0 : 1; cflags |= fmpq_poly_is_canonical(g) ? 0 : 2; result = (fmpq_poly_equal(f, g) && !cflags); if (!result) { flint_printf("FAIL (aliasing 1):\n"); fmpq_poly_debug(f), flint_printf("\n\n"); fmpq_poly_debug(g), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Check aliasing of the second argument */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(g, state, n_randint(state, 50), 100); fmpq_poly_randtest(h, state, n_randint(state, 20), 50); fmpq_poly_compose(f, g, h); fmpq_poly_compose(h, g, h); cflags |= fmpq_poly_is_canonical(f) ? 0 : 1; cflags |= fmpq_poly_is_canonical(h) ? 0 : 2; result = (fmpq_poly_equal(f, h) && !cflags); if (!result) { flint_printf("FAIL (aliasing 2):\n"); fmpq_poly_debug(f), flint_printf("\n\n"); fmpq_poly_debug(h), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Compare with the naive method for g(h(t)) */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h, s, t, u; mpq_t c; slong k; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_init(u); mpq_init(c); fmpq_poly_randtest(g, state, n_randint(state, 20), 65); fmpq_poly_randtest(h, state, n_randint(state, 20), 65); fmpq_poly_zero(s); fmpq_poly_set_ui(t, UWORD(1)); for (k = WORD(0); k < g->length; k++) { fmpq_poly_get_coeff_mpq(c, g, k); fmpq_poly_scalar_mul_mpq(u, t, c); fmpq_poly_add(s, s, u); fmpq_poly_mul(t, t, h); } fmpq_poly_compose(f, g, h); result = (fmpq_poly_equal(f, s)); if (!result) { flint_printf("FAIL (compare with naive):\n"); flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n\n"); flint_printf("h = "), fmpq_poly_debug(h), flint_printf("\n\n"); flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n\n"); flint_printf("s = "), fmpq_poly_debug(s), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(s); fmpq_poly_clear(t); fmpq_poly_clear(u); mpq_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; ulong cflags = 0UL; printf("rem...."); fflush(stdout); flint_randinit(state); /* Check aliasing of r and a */ for (i = 0; i < 2000; i++) { fmpq_poly_t a, b, r; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(r); fmpq_poly_randtest(a, state, n_randint(state, 50), 200); fmpq_poly_randtest_not_zero(b, state, n_randint(state, 50) + 1, 200); fmpq_poly_rem(r, a, b); fmpq_poly_rem(a, a, b); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(r) ? 0 : 2; result = (fmpq_poly_equal(r, a) && !cflags); if (!result) { printf("FAIL:\n"); printf("r = "), fmpq_poly_debug(r), printf("\n\n"); printf("a = "), fmpq_poly_debug(a), printf("\n\n"); printf("b = "), fmpq_poly_debug(b), printf("\n\n"); printf("cflags = %lu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(r); } /* Check aliasing of r and b */ for (i = 0; i < 2000; i++) { fmpq_poly_t a, b, r; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(r); fmpq_poly_randtest(a, state, n_randint(state, 50), 200); fmpq_poly_randtest_not_zero(b, state, n_randint(state, 50) + 1, 200); fmpq_poly_rem(r, a, b); fmpq_poly_rem(b, a, b); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; cflags |= fmpq_poly_is_canonical(r) ? 0 : 2; result = (fmpq_poly_equal(r, b) && !cflags); if (!result) { printf("FAIL:\n"); printf("r = "), fmpq_poly_debug(r), printf("\n\n"); printf("a = "), fmpq_poly_debug(a), printf("\n\n"); printf("b = "), fmpq_poly_debug(b), printf("\n\n"); printf("cflags = %lu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(r); } /* Compare with divrem */ for (i = 0; i < 2000; i++) { fmpq_poly_t a, b, q, r, r2; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(q); fmpq_poly_init(r); fmpq_poly_init(r2); fmpq_poly_randtest(a, state, n_randint(state, 50), 200); fmpq_poly_randtest_not_zero(b, state, n_randint(state, 50) + 1, 200); fmpq_poly_divrem(q, r, a, b); fmpq_poly_rem(r2, a, b); cflags |= fmpq_poly_is_canonical(q) ? 0 : 1; cflags |= fmpq_poly_is_canonical(r2) ? 0 : 2; result = (fmpq_poly_equal(r, r2) && !cflags); if (!result) { printf("FAIL:\n"); printf("a = "), fmpq_poly_debug(a), printf("\n\n"); printf("b = "), fmpq_poly_debug(b), printf("\n\n"); printf("q = "), fmpq_poly_debug(q), printf("\n\n"); printf("r = "), fmpq_poly_debug(r), printf("\n\n"); printf("r2 = "), fmpq_poly_debug(r2), printf("\n\n"); printf("cflags = %lu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(q); fmpq_poly_clear(r); fmpq_poly_clear(r2); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int cflags = 0, i, result; flint_rand_t state; printf("xgcd...."); fflush(stdout); flint_randinit(state); /* Generic case, where a and b are coprime *******************************/ /* Verify d == s a + t b */ for (i = 0; i < 100; i++) { fmpq_poly_t a, b, d, e, f, s, t; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(d); fmpq_poly_init(e); fmpq_poly_init(f); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_randtest(a, state, n_randint(state, 60), 80); fmpq_poly_randtest(b, state, n_randint(state, 60), 80); fmpq_poly_xgcd(d, s, t, a, b); fmpq_poly_mul(e, s, a); fmpq_poly_mul(f, t, b); fmpq_poly_add(e, e, f); cflags |= fmpq_poly_is_canonical(d) ? 0 : 1; cflags |= fmpq_poly_is_canonical(s) ? 0 : 2; cflags |= fmpq_poly_is_canonical(t) ? 0 : 4; result = (fmpq_poly_equal(d, e) && !cflags); if (!result) { printf("FAIL (correctness #1):\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(d), printf("\n\n"); fmpq_poly_debug(s), printf("\n\n"); fmpq_poly_debug(t), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(d); fmpq_poly_clear(e); fmpq_poly_clear(f); fmpq_poly_clear(s); fmpq_poly_clear(t); } /* Verify consistency with GCD */ for (i = 0; i < 100; i++) { fmpq_poly_t a, b, d, s, t; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(d); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_randtest(a, state, n_randint(state, 60), 80); fmpq_poly_randtest(b, state, n_randint(state, 60), 80); fmpq_poly_xgcd(d, s, t, a, b); fmpq_poly_gcd(a, a, b); cflags |= fmpq_poly_is_canonical(d) ? 0 : 1; cflags |= fmpq_poly_is_canonical(s) ? 0 : 2; cflags |= fmpq_poly_is_canonical(t) ? 0 : 4; result = (fmpq_poly_equal(d, a) && !cflags); if (!result) { printf("FAIL (GCD #1):\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(d), printf("\n\n"); fmpq_poly_debug(s), printf("\n\n"); fmpq_poly_debug(t), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(d); fmpq_poly_clear(s); fmpq_poly_clear(t); } /* Generic case when a, b are most likely co-prime ***********************/ /* Verify d == s a + t b */ for (i = 0; i < 100; i++) { fmpq_poly_t a, b, d, s, t, z; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(d); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_init(z); fmpq_poly_randtest(a, state, n_randint(state, 60), 80); fmpq_poly_randtest(b, state, n_randint(state, 60), 80); fmpq_poly_randtest(z, state, n_randint(state, 20), 20); fmpq_poly_mul(a, a, z); fmpq_poly_mul(b, b, z); fmpq_poly_xgcd(d, s, t, a, b); fmpq_poly_mul(a, s, a); fmpq_poly_mul(b, t, b); fmpq_poly_add(a, a, b); cflags |= fmpq_poly_is_canonical(d) ? 0 : 1; cflags |= fmpq_poly_is_canonical(s) ? 0 : 2; cflags |= fmpq_poly_is_canonical(t) ? 0 : 4; result = (fmpq_poly_equal(d, a) && !cflags); if (!result) { printf("FAIL (correctness #2):\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(d), printf("\n\n"); fmpq_poly_debug(s), printf("\n\n"); fmpq_poly_debug(t), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(d); fmpq_poly_clear(s); fmpq_poly_clear(t); fmpq_poly_clear(z); } /* Verify consistency with GCD */ for (i = 0; i < 100; i++) { fmpq_poly_t a, b, d, s, t, z; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(d); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_init(z); fmpq_poly_randtest(a, state, n_randint(state, 60), 80); fmpq_poly_randtest(b, state, n_randint(state, 60), 80); fmpq_poly_randtest(z, state, n_randint(state, 20), 20); fmpq_poly_mul(a, a, z); fmpq_poly_mul(b, b, z); fmpq_poly_xgcd(d, s, t, a, b); fmpq_poly_gcd(a, a, b); cflags |= fmpq_poly_is_canonical(d) ? 0 : 1; cflags |= fmpq_poly_is_canonical(s) ? 0 : 2; cflags |= fmpq_poly_is_canonical(t) ? 0 : 4; result = (fmpq_poly_equal(d, a) && !cflags); if (!result) { printf("FAIL (GCD #2):\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(d), printf("\n\n"); fmpq_poly_debug(s), printf("\n\n"); fmpq_poly_debug(t), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(d); fmpq_poly_clear(s); fmpq_poly_clear(t); fmpq_poly_clear(z); } flint_randclear(state); _fmpz_cleanup(); 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; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("resultant_div...."); fflush(stdout); for (i = 0; i < 50; i++) { fmpq_poly_t f, g, h, p; fmpq_t x, y, z, zz; fmpz_t den; slong nbits; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(p); fmpq_poly_init(h); fmpq_init(x); fmpq_init(y); fmpq_init(z); fmpq_init(zz); fmpz_init(den); fmpq_poly_randtest(f, state, n_randint(state, 50), 100); fmpq_poly_randtest(g, state, n_randint(state, 50), 100); fmpq_poly_randtest(h, state, n_randint(state, 50), 100); fmpz_set(den, fmpq_poly_denref(f)); fmpq_poly_scalar_mul_fmpz(f, f, den); fmpz_set(den, fmpq_poly_denref(g)); fmpq_poly_scalar_mul_fmpz(g, g, den); fmpz_set(den, fmpq_poly_denref(h)); fmpq_poly_scalar_mul_fmpz(h, h, den); fmpq_poly_mul(p, f, g); fmpq_poly_resultant(x, f, h); if (!fmpz_is_one(fmpq_denref(x))) { flint_printf("FAIL resultant not integral\n"); flint_printf("f = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("y = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_resultant(y, g, h); if (!fmpz_is_one(fmpq_denref(y))) { flint_printf("FAIL resultant not integral\n"); flint_printf("h = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("z = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_resultant(z, p, h); if (!fmpz_is_one(fmpq_denref(z))) { flint_printf("FAIL resultant not integral\n"); flint_printf("p = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("y = "), fmpq_print(y), flint_printf("\n\n"); abort(); } if (fmpq_is_zero(z)) { fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_clear(zz); fmpz_clear(den); continue; } nbits = (slong)fmpz_bits(fmpq_numref(y)) + 1; fmpq_poly_resultant_div(z, p, h, fmpq_numref(x), nbits); fmpq_poly_resultant(zz, p, h); result = fmpq_equal(z, y); if (!result) { flint_printf("FAIL (res(p, g)/div == res(p, g)/div:\n"); flint_printf("p = "), fmpq_poly_print_pretty(p, "x"), flint_printf("\n\n"); flint_printf("h = "), fmpq_poly_print_pretty(h, "x"), flint_printf("\n\n"); flint_printf("res(p, h) = "), fmpq_print(zz), flint_printf("\n\n"); flint_printf("res(p, h) = "), fmpq_print(x), flint_printf(" * "), fmpq_print(y), flint_printf("\n\n"); flint_printf("supplied divisor = "), fmpq_print(x), flint_printf("\n\n"); flint_printf("nbits = %wu\n\n", nbits); flint_printf("divisor found = "), fmpq_print(z), flint_printf("\n\n"); flint_printf("correct result = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_clear(zz); fmpz_clear(den); } 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; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("add...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_add(c, a, b); fmpq_poly_add(a, a, b); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(a, c) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); 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); } /* Check aliasing of b and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_add(c, a, b); fmpq_poly_add(b, a, b); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(b, c) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); 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() { long iter; flint_rand_t state; printf("compose_series_brent_kung...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 3000; iter++) { long qbits1, qbits2, rbits1, rbits2, rbits3, n; fmpq_poly_t A, B, C; fmpcb_poly_t a, b, c, d; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); n = 2 + n_randint(state, 25); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); fmpcb_poly_init(a); fmpcb_poly_init(b); fmpcb_poly_init(c); fmpcb_poly_init(d); fmpq_poly_randtest(A, state, 1 + n_randint(state, 25), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 25), qbits2); fmpq_poly_set_coeff_ui(B, 0, 0); fmpq_poly_compose_series(C, A, B, n); fmpcb_poly_set_fmpq_poly(a, A, rbits1); fmpcb_poly_set_fmpq_poly(b, B, rbits2); fmpcb_poly_compose_series_brent_kung(c, a, b, n, rbits3); if (!fmpcb_poly_contains_fmpq_poly(c, C)) { printf("FAIL\n\n"); printf("n = %ld, bits3 = %ld\n", n, rbits3); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("C = "); fmpq_poly_print(C); printf("\n\n"); printf("a = "); fmpcb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmpcb_poly_printd(b, 15); printf("\n\n"); printf("c = "); fmpcb_poly_printd(c, 15); printf("\n\n"); abort(); } fmpcb_poly_set(d, a); fmpcb_poly_compose_series_brent_kung(d, d, b, n, rbits3); if (!fmpcb_poly_equal(d, c)) { printf("FAIL (aliasing 1)\n\n"); abort(); } fmpcb_poly_set(d, b); fmpcb_poly_compose_series_brent_kung(d, a, d, n, rbits3); if (!fmpcb_poly_equal(d, c)) { printf("FAIL (aliasing 2)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); fmpcb_poly_clear(a); fmpcb_poly_clear(b); fmpcb_poly_clear(c); fmpcb_poly_clear(d); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; FLINT_TEST_INIT(state); { ulong k; arb_t a,b; arf_t c,d; fmpq_poly_t p; arb_init(a); arb_init(b); arf_init(c); arf_init(d); /* x+1 */ fmpq_poly_init(p); fmpq_poly_set_coeff_si(p, 0, 1); fmpq_poly_set_coeff_si(p, 1, 1); for (iter = 0; iter < 5000; iter++) { k = n_randint(state, 10000); arb_set_si(a, k); fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100)); if (!arb_equal_si(b, k + 1)) { printf("FAIL (fmpq_poly_evaluate_arb):\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } arf_set_si(c, k); fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100)); if (!arf_equal_si(d, k + 1)) { printf("FAIL (fmpq_poly_evaluate_arf):\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } } /* x^2 */ fmpq_poly_zero(p); fmpq_poly_set_coeff_si(p, 2, 1); for (iter = 0; iter < 1000; iter++) { k = n_randint(state, 10000); arb_set_si(a, k); fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100)); if (!arb_equal_si(b, k * k)) { printf("Error (test_fmpq_poly_evaluate_arb):\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } arf_set_si(c, k); fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100)); if (!arf_equal_si(d, k * k)) { printf("Error (test_fmpq_poly_evaluate_arf):\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); abort(); } } fmpq_poly_clear(p); arb_clear(a); arb_clear(b); arf_clear(c); arf_clear(d); } /* check evaluate_arb agains exact evaluate_fmpq */ for (iter = 0; iter < 1000; iter++) { fmpq_poly_t p; fmpq_t x,y; arb_t a,b; fmpq_poly_init(p); fmpq_init(x); fmpq_init(y); arb_init(a); arb_init(b); fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10); fmpq_randtest(x, state, 10); arb_set_fmpq(a, x, 64); fmpq_poly_evaluate_fmpq(y, p, x); fmpq_poly_evaluate_arb(b, p, a, 60); if (!arb_contains_fmpq(b, y)) { printf("FAIL (y not in b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("x = "); fmpq_print(x); printf("\n"); printf("y = "); fmpq_print(y); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_evaluate_arb(a, p, a, 60); if (!arb_equal(a,b)) { printf("FAIL (a not equal b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("x = "); fmpq_print(x); printf("\n"); printf("y = "); fmpq_print(y); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); arb_clear(a); arb_clear(b); } /* test aliasing */ for (iter = 0; iter < 1000; iter++) { fmpq_poly_t p; arb_t a,b; arf_t c,d; fmpq_poly_init(p); arb_init(a); arb_init(b); arf_init(c); arf_init(d); fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10); arb_randtest(a, state, 60, 10); arb_randtest(b, state, 60, 10); arf_randtest(c, state, 60, 10); arf_randtest(d, state, 60, 10); fmpq_poly_evaluate_arb(b, p, a, 60); fmpq_poly_evaluate_arb(a, p, a, 60); if (!arb_equal(a, b)) { printf("FAIL (a not equal b):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("a = "); arb_print(a); printf("\n"); printf("b = "); arb_print(b); printf("\n"); abort(); } fmpq_poly_evaluate_arf(d, p, c, 60); fmpq_poly_evaluate_arf(c, p, c, 60); if (!arf_equal(c, d)) { printf("FAIL (c not equal d):\n"); printf("p = "); fmpq_poly_print(p); printf("\n"); printf("c = "); arf_print(c); printf("\n"); printf("d = "); arf_print(d); printf("\n"); } fmpq_poly_clear(p); arb_clear(a); arb_clear(b); arf_clear(c); arf_clear(d); } FLINT_TEST_CLEANUP(state); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("evaluate_horner...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t F; fmpq_t X, Y; arb_poly_t f; arb_t x, y; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_init(F); fmpq_init(X); fmpq_init(Y); arb_poly_init(f); arb_init(x); arb_init(y); fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1); fmpq_randtest(X, state, qbits2); fmpq_poly_evaluate_fmpq(Y, F, X); arb_poly_set_fmpq_poly(f, F, rbits1); arb_set_fmpq(x, X, rbits2); arb_poly_evaluate_horner(y, f, x, rbits3); if (!arb_contains_fmpq(y, Y)) { flint_printf("FAIL\n\n"); flint_printf("F = "); fmpq_poly_print(F); flint_printf("\n\n"); flint_printf("X = "); fmpq_print(X); flint_printf("\n\n"); flint_printf("Y = "); fmpq_print(Y); flint_printf("\n\n"); flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n"); flint_printf("y = "); arb_printd(y, 15); flint_printf("\n\n"); abort(); } /* aliasing */ arb_poly_evaluate_horner(x, f, x, rbits3); if (!arb_contains_fmpq(x, Y)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(F); fmpq_clear(X); fmpq_clear(Y); arb_poly_clear(f); arb_clear(x); arb_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("div_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong m, n, p, qbits, rbits1, rbits2; fmpq_poly_t A, B, C; arb_poly_t a, b, c, d; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); p = 1 + n_randint(state, 20); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, m, qbits); do { fmpq_poly_randtest_not_zero(B, state, n, qbits); } while (B->coeffs[0] == 0); fmpq_poly_div_series(C, A, B, p); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits1); arb_poly_div_series(c, a, b, p, rbits2); if (!arb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_abort(); } arb_poly_set(d, a); arb_poly_div_series(d, d, b, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); flint_abort(); } arb_poly_set(d, b); arb_poly_div_series(d, a, d, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); flint_abort(); } arb_poly_set(d, b); arb_poly_div_series(c, d, d, p, rbits2); arb_poly_div_series(d, d, d, p, rbits2); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 3)\n\n"); flint_abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
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 i, result; FLINT_TEST_INIT(state); flint_printf("compose_series_brent_kung...."); fflush(stdout); /* Check aliasing of the first argument */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h; slong n; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(g, state, n_randint(state, 40), 80); fmpq_poly_randtest(h, state, n_randint(state, 20), 50); fmpq_poly_set_coeff_ui(h, 0, 0); n = n_randint(state, 20); fmpq_poly_compose_series_brent_kung(f, g, h, n); fmpq_poly_compose_series_brent_kung(g, g, h, n); result = (fmpq_poly_equal(f, g)); if (!result) { flint_printf("FAIL (aliasing 1):\n"); fmpq_poly_print(f), flint_printf("\n\n"); fmpq_poly_print(g), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Check aliasing of the second argument */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h; slong n; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(g, state, n_randint(state, 40), 80); fmpq_poly_randtest(h, state, n_randint(state, 20), 50); fmpq_poly_set_coeff_ui(h, 0, 0); n = n_randint(state, 20); fmpq_poly_compose_series_brent_kung(f, g, h, n); fmpq_poly_compose_series_brent_kung(h, g, h, n); result = (fmpq_poly_equal(f, h)); if (!result) { flint_printf("FAIL (aliasing 2):\n"); fmpq_poly_print(f), flint_printf("\n\n"); fmpq_poly_print(h), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Compare with compose */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { fmpq_poly_t f, g, h, s, t; slong n; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_init(s); fmpq_poly_init(t); fmpq_poly_randtest(g, state, n_randint(state, 40), 80); fmpq_poly_randtest(h, state, n_randint(state, 20), 50); fmpq_poly_set_coeff_ui(h, 0, 0); n = n_randint(state, 20); fmpq_poly_compose(s, g, h); fmpq_poly_truncate(s, n); fmpq_poly_compose_series_brent_kung(f, g, h, n); result = (fmpq_poly_equal(f, s)); if (!result) { flint_printf("FAIL (comparison):\n"); flint_printf("n = %wd\n", n); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("h = "), fmpq_poly_print(h), flint_printf("\n\n"); flint_printf("f = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("s = "), fmpq_poly_print(s), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(s); fmpq_poly_clear(t); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int cflags = 0, i, result; flint_rand_t state; printf("lcm...."); fflush(stdout); flint_randinit(state); /* Check aliasing of a and c */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_lcm(c, a, b); fmpq_poly_lcm(a, a, b); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(a, c) && !cflags); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(c), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } /* Check aliasing of b and c */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_lcm(c, a, b); fmpq_poly_lcm(b, a, b); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(b, c) && !cflags); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(c), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } /* Generic case when a, b are most likely co-prime ***********************/ /* Verify commutativity and that c is monic */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_lcm(c, a, b); fmpq_poly_lcm(a, b, a); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(a, c) && !cflags && (fmpq_poly_is_zero(c) || fmpq_poly_is_monic(c))); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(c), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } /* Verify that LCM(a, b) GCD(a, b) == a b */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, lcm, gcd; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(lcm); fmpq_poly_init(gcd); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_lcm(lcm, a, b); fmpq_poly_gcd(gcd, a, b); fmpq_poly_mul(lcm, lcm, gcd); fmpq_poly_mul(a, a, b); fmpq_poly_make_monic(a, a); result = fmpq_poly_equal(lcm, a); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(lcm), printf("\n\n"); fmpq_poly_debug(gcd), printf("\n\n"); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(lcm); fmpq_poly_clear(gcd); } /* Case when a, b are not co-prime ***************************************/ /* Verify commutativity and that c is monic */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, c, t; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_init(t); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_randtest(t, state, n_randint(state, 50), 20); fmpq_poly_mul(a, a, t); fmpq_poly_mul(b, b, t); fmpq_poly_lcm(c, a, b); fmpq_poly_lcm(a, b, a); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(a, c) && !cflags && (fmpq_poly_is_zero(c) || fmpq_poly_is_monic(c))); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(c), printf("\n\n"); printf("cflags = %d\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); fmpq_poly_clear(t); } /* Verify that LCM(a, b) GCD(a, b) == a b */ for (i = 0; i < 1000; i++) { fmpq_poly_t a, b, lcm, gcd, t; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(lcm); fmpq_poly_init(gcd); fmpq_poly_init(t); fmpq_poly_randtest(a, state, n_randint(state, 100), 100); fmpq_poly_randtest(b, state, n_randint(state, 100), 100); fmpq_poly_randtest(t, state, n_randint(state, 50), 20); fmpq_poly_mul(a, a, t); fmpq_poly_mul(b, b, t); fmpq_poly_lcm(lcm, a, b); fmpq_poly_gcd(gcd, a, b); fmpq_poly_mul(lcm, lcm, gcd); fmpq_poly_mul(a, a, b); fmpq_poly_make_monic(a, a); result = fmpq_poly_equal(lcm, a); if (!result) { printf("FAIL:\n"); fmpq_poly_debug(a), printf("\n\n"); fmpq_poly_debug(b), printf("\n\n"); fmpq_poly_debug(lcm), printf("\n\n"); fmpq_poly_debug(gcd), printf("\n\n"); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(lcm); fmpq_poly_clear(gcd); fmpq_poly_clear(t); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { long iter; flint_rand_t state; printf("exp_series_basecase...."); fflush(stdout); flint_randinit(state); /* compare with fmpq_poly */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2; fmpq_poly_t A, B; fmprb_poly_t a, b; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 40); n = 1 + n_randint(state, 40); fmpq_poly_init(A); fmpq_poly_init(B); fmprb_poly_init(a); fmprb_poly_init(b); fmpq_poly_randtest(A, state, m, qbits); fmpq_poly_set_coeff_ui(A, 0, 0UL); fmpq_poly_exp_series(B, A, n); fmprb_poly_set_fmpq_poly(a, A, rbits1); fmprb_poly_exp_series_basecase(b, a, n, rbits2); if (!fmprb_poly_contains_fmpq_poly(b, B)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("a = "); fmprb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmprb_poly_printd(b, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmprb_poly_clear(a); fmprb_poly_clear(b); } /* test aliasing */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2; fmpq_poly_t A; fmprb_poly_t a, b; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 40); n = 1 + n_randint(state, 40); fmpq_poly_init(A); fmprb_poly_init(a); fmprb_poly_init(b); fmpq_poly_randtest_small(A, state, m, qbits); fmprb_poly_set_fmpq_poly(a, A, rbits1); fmprb_poly_exp_series_basecase(b, a, n, rbits2); fmprb_poly_exp_series_basecase(a, a, n, rbits2); if (!fmprb_poly_equal(a, b)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("a = "); fmprb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmprb_poly_printd(b, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); fmprb_poly_clear(a); fmprb_poly_clear(b); } /* test that log(exp(f)) contains f */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2, rbits3; fmpq_poly_t A; fmprb_poly_t a, b, c; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 40); n = 1 + n_randint(state, 40); fmpq_poly_init(A); fmprb_poly_init(a); fmprb_poly_init(b); fmprb_poly_init(c); do { fmpq_poly_randtest_small(A, state, m, qbits); fmprb_poly_set_fmpq_poly(a, A, rbits1); fmprb_poly_exp_series_basecase(b, a, n, rbits3); } while (b->length == 0 || fmprb_contains_zero(b->coeffs)); fmprb_poly_log_series(c, b, n, rbits2); fmpq_poly_truncate(A, n); if (!fmprb_poly_contains_fmpq_poly(c, A)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("bits3 = %ld\n", rbits3); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("a = "); fmprb_poly_printd(a, 15); printf("\n\n"); printf("b = "); fmprb_poly_printd(b, 15); printf("\n\n"); printf("c = "); fmprb_poly_printd(c, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); fmprb_poly_clear(a); fmprb_poly_clear(b); fmprb_poly_clear(c); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("compose...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 3000 * arb_test_multiplier(); iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, C; acb_poly_t a, b, c, d; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); acb_poly_init(d); fmpq_poly_randtest(A, state, 1 + n_randint(state, 20), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2); fmpq_poly_compose(C, A, B); acb_poly_randtest(c, state, 1 + n_randint(state, 20), rbits1, 4); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_set_fmpq_poly(b, B, rbits2); acb_poly_compose(c, a, b, rbits3); if (!acb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits3 = %wd\n", rbits3); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n"); flint_abort(); } acb_poly_set(d, a); acb_poly_compose(d, d, b, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); flint_abort(); } acb_poly_set(d, b); acb_poly_compose(d, a, d, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); flint_abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); acb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("atan_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { slong m, n, qbits, rbits1, rbits2; fmpq_poly_t A; arb_poly_t a, b, c, d; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); fmpq_poly_init(A); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, m, qbits); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_randtest(b, state, 1 + n_randint(state, 30), rbits1, 5); arb_poly_atan_series(b, a, n, rbits2); /* Check 2 atan(x) = atan(2x/(1-x^2)) + C */ arb_poly_mullow(c, a, a, n, rbits2); arb_poly_one(d); arb_poly_sub(c, d, c, rbits2); arb_poly_add(d, a, a, rbits2); if (arb_poly_length(c) != 0) { arb_poly_div_series(c, d, c, n, rbits2); arb_poly_atan_series(c, c, n, rbits2); arb_poly_add(d, b, b, rbits2); /* TODO: also check the first coefficient */ arb_poly_set_coeff_si(c, 0, 0); arb_poly_set_coeff_si(d, 0, 0); if (!arb_poly_overlaps(c, d)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } } arb_poly_atan_series(a, a, n, rbits2); if (!arb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }