int
main(void)
{
int i, result;
flint_rand_t state;
ulong cflags = 0UL;
printf("sinh_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and c */
for (i = 0; i < 200; i++)
{
fmpq_poly_t a, b;
long 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, 0UL);
fmpq_poly_canonicalise(a);
fmpq_poly_sinh_series(b, a, n);
fmpq_poly_sinh_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)
{
printf("FAIL:\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check asinh(sinh(a)) = a */
for (i = 0; i < 200; i++)
{
fmpq_poly_t a, sinha, asinhsinha;
long n = n_randint(state, 80) + 1;
fmpq_poly_init(a);
fmpq_poly_init(sinha);
fmpq_poly_init(asinhsinha);
fmpq_poly_randtest_not_zero(a, state, n_randint(state, 60) + 1, 80);
fmpq_poly_set_coeff_ui(a, 0, 0UL);
fmpq_poly_sinh_series(sinha, a, n);
fmpq_poly_asinh_series(asinhsinha, sinha, n);
fmpq_poly_truncate(a, n);
cflags |= fmpq_poly_is_canonical(sinha) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(asinhsinha) ? 0 : 2;
result = (fmpq_poly_equal(asinhsinha, a) && !cflags);
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpq_poly_debug(a), printf("\n\n");
printf("sinh(a) = "), fmpq_poly_debug(sinha), printf("\n\n");
printf("asinh(sinh(a)) = "), fmpq_poly_debug(asinhsinha), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(sinha);
fmpq_poly_clear(asinhsinha);
}
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("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()
{
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("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()
{
slong iter;
flint_rand_t state;
flint_printf("legendre_p_ui_root....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100 * arb_test_multiplier(); iter++)
{
ulong n, k;
slong prec;
arb_ptr roots, weights;
arb_poly_t pol;
arb_t s;
fmpq_poly_t pol2;
n = 1 + n_randint(state, 100);
prec = 20 + n_randint(state, 500);
roots = _arb_vec_init(n);
weights = _arb_vec_init(n);
arb_poly_init(pol);
fmpq_poly_init(pol2);
arb_init(s);
for (k = 0; k < n; k++)
{
if (k > n / 2 && n_randint(state, 2))
{
arb_neg(roots + k, roots + n - k - 1);
arb_set(weights + k, weights + n - k - 1);
}
else
{
arb_hypgeom_legendre_p_ui_root(roots + k, weights + k, n, k, prec);
}
}
arb_poly_product_roots(pol, roots, n, prec);
/* fmpq_poly_legendre_p(pol2, n); */
arith_legendre_polynomial(pol2, n);
arb_set_fmpz(s, pol2->coeffs + n);
arb_div_fmpz(s, s, pol2->den, prec);
arb_poly_scalar_mul(pol, pol, s, prec);
if (!arb_poly_contains_fmpq_poly(pol, pol2))
{
flint_printf("FAIL: polynomial containment\n\n");
flint_printf("n = %wu, prec = %wd\n\n", n, prec);
flint_printf("pol = "); arb_poly_printd(pol, 30); flint_printf("\n\n");
flint_printf("pol2 = "); fmpq_poly_print(pol2); flint_printf("\n\n");
flint_abort();
}
arb_zero(s);
for (k = 0; k < n; k++)
{
arb_add(s, s, weights + k, prec);
}
if (!arb_contains_si(s, 2))
{
flint_printf("FAIL: sum of weights\n\n");
flint_printf("n = %wu, prec = %wd\n\n", n, prec);
flint_printf("s = "); arb_printn(s, 30, 0); flint_printf("\n\n");
flint_abort();
}
_arb_vec_clear(roots, n);
_arb_vec_clear(weights, n);
arb_poly_clear(pol);
fmpq_poly_clear(pol2);
arb_clear(s);
}
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
arb_t x1, x2, w1, w2;
ulong n, k;
slong prec1, prec2;
arb_init(x1);
arb_init(x2);
arb_init(w1);
arb_init(w2);
n = 1 + n_randtest(state) % 100000;
if (n_randint(state, 2) || n == 1)
k = n_randtest(state) % n;
else
k = n / 2 - (n_randtest(state) % (n / 2));
prec1 = 2 + n_randtest(state) % 2000;
prec2 = 2 + n_randtest(state) % 2000;
arb_hypgeom_legendre_p_ui_root(x1, w1, n, k, prec1);
if (n_randint(state, 10) == 0)
arb_hypgeom_legendre_p_ui_root(x1, NULL, n, k, prec1);
arb_hypgeom_legendre_p_ui_root(x2, w2, n, k, prec2);
if (!arb_overlaps(x1, x2) || !arb_overlaps(w1, w2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu, k = %wu, prec1 = %wd, prec2 = %wd\n\n", n, k, prec1, prec2);
flint_printf("x1 = "); arb_printn(x1, 100, 0); flint_printf("\n\n");
flint_printf("x2 = "); arb_printn(x2, 100, 0); flint_printf("\n\n");
flint_printf("w1 = "); arb_printn(w1, 100, 0); flint_printf("\n\n");
flint_printf("w2 = "); arb_printn(w2, 100, 0); flint_printf("\n\n");
flint_abort();
}
if (arb_rel_accuracy_bits(x1) < prec1 - 3 || arb_rel_accuracy_bits(w1) < prec1 - 3)
{
flint_printf("FAIL: accuracy\n\n");
flint_printf("n = %wu, k = %wu, prec1 = %wd\n\n", n, k, prec1);
flint_printf("acc(x1) = %wd, acc(w1) = %wd\n\n", arb_rel_accuracy_bits(x1), arb_rel_accuracy_bits(w1));
flint_printf("x1 = "); arb_printn(x1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_printf("w1 = "); arb_printn(w1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_abort();
}
if (arb_rel_accuracy_bits(x2) < prec2 - 3 || arb_rel_accuracy_bits(w2) < prec2 - 3)
{
flint_printf("FAIL: accuracy 2\n\n");
flint_printf("n = %wu, k = %wu, prec2 = %wd\n\n", n, k, prec2);
flint_printf("acc(x2) = %wd, acc(w2) = %wd\n\n", arb_rel_accuracy_bits(x2), arb_rel_accuracy_bits(w2));
flint_printf("x2 = "); arb_printn(x2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_printf("w2 = "); arb_printn(w2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_abort();
}
arb_clear(x1);
arb_clear(x2);
arb_clear(w1);
arb_clear(w2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sub....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpq_poly */
for (iter = 0; iter < 10000; 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_sub(C, A, B);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_sub(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("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_sub(d, d, b, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
acb_poly_set(d, b);
acb_poly_sub(d, a, d, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\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);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("interpolate_newton....");
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 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_newton(S, xs, ys, n, rbits3);
if (!arb_poly_contains_fmpq_poly(S, P))
{
flint_printf("FAIL:\n");
flint_printf("P = "); fmpq_poly_print(P); flint_printf("\n\n");
flint_printf("R = "); arb_poly_printd(R, 15); flint_printf("\n\n");
flint_printf("S = "); arb_poly_printd(S, 15); flint_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();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("compose_horner....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
long 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, 20), qbits1);
fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2);
fmpq_poly_compose(C, A, B);
arb_poly_set_fmpq_poly(a, A, rbits1);
arb_poly_set_fmpq_poly(b, B, rbits2);
arb_poly_compose_horner(c, a, b, rbits3);
if (!arb_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 = "); arb_poly_printd(a, 15); printf("\n\n");
printf("b = "); arb_poly_printd(b, 15); printf("\n\n");
printf("c = "); arb_poly_printd(c, 15); printf("\n\n");
abort();
}
arb_poly_set(d, a);
arb_poly_compose_horner(d, d, b, rbits3);
if (!arb_poly_equal(d, c))
{
printf("FAIL (aliasing 1)\n\n");
abort();
}
arb_poly_set(d, b);
arb_poly_compose_horner(d, a, d, rbits3);
if (!arb_poly_equal(d, c))
{
printf("FAIL (aliasing 2)\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();
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, result;
ulong cflags = UWORD(0);
mpq_t n1, n2;
FLINT_TEST_INIT(state);
flint_printf("get/set_coeff_fmpz....");
fflush(stdout);
mpq_init(n1);
mpq_init(n2);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_poly_t a;
fmpz_t x1, x2;
slong coeff, len;
fmpq_poly_init(a);
fmpz_init(x1);
fmpz_init(x2);
len = (slong) (n_randint(state, 100) + 1);
for (j = 0; j < 100; j++)
{
fmpz_randtest(x1, state, 200);
fmpz_get_mpz(mpq_numref(n1), x1);
flint_mpz_set_si(mpq_denref(n1), 1);
coeff = (slong) n_randint(state, len);
fmpq_poly_set_coeff_fmpz(a, coeff, x1);
fmpq_poly_get_coeff_mpq(n2, a, coeff);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
result = (mpq_equal(n1, n2) && !cflags);
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), fmpq_poly_debug(a), flint_printf("\n\n");
flint_printf("coeff = %wd\n\n", coeff);
flint_printf("len = %wd\n\n", len);
flint_printf("cflags = %wu\n\n", cflags);
gmp_printf("n1 = %Qd\n\n", n1);
gmp_printf("n2 = %Qd\n\n", n2);
abort();
}
}
fmpz_clear(x1);
fmpz_clear(x2);
fmpq_poly_clear(a);
}
mpq_clear(n1);
mpq_clear(n2);
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("asinh_series....");
fflush(stdout);
/* Check aliasing of a and c */
for (i = 0; i < 20 * 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(0));
fmpq_poly_canonicalise(a);
fmpq_poly_asinh_series(b, a, n);
fmpq_poly_asinh_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 asinh(A) = atanh(A/sqrt(1+A^2)) */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
fmpq_poly_t A, B, asinhA, atanhB;
slong n = n_randint(state, 80) + 1;
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpq_poly_init(asinhA);
fmpq_poly_init(atanhB);
fmpq_poly_randtest_not_zero(A, state, n_randint(state, 80) + 1, 80);
fmpq_poly_set_coeff_ui(A, 0, UWORD(0));
fmpq_poly_mullow(B, A, A, n);
fmpq_poly_set_coeff_ui(B, 0, UWORD(1));
fmpq_poly_invsqrt_series(B, B, n);
fmpq_poly_mullow(B, A, B, n);
fmpq_poly_asinh_series(asinhA, A, n);
fmpq_poly_atanh_series(atanhB, B, n);
cflags |= fmpq_poly_is_canonical(asinhA) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(atanhB) ? 0 : 2;
result = (fmpq_poly_equal(asinhA, atanhB) && !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("asinh(A) = "), fmpq_poly_debug(asinhA), flint_printf("\n\n");
flint_printf("atanh(B) = "), fmpq_poly_debug(atanhB), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(asinhA);
fmpq_poly_clear(atanhB);
}
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("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 i, result;
padic_ctx_t ctx;
fmpz_t p;
slong N;
FLINT_TEST_INIT(state);
flint_printf("mul... ");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN)
+ PADIC_TEST_PREC_MIN;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(a, 0, N);
padic_poly_init2(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_randtest(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_mul(b, b, c, ctx);
result = (padic_poly_equal(a, b) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (aliasing a and b):\n");
padic_poly_print(a, ctx), flint_printf("\n\n");
padic_poly_print(b, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
/* Check aliasing of a and c */
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN)
+ PADIC_TEST_PREC_MIN;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(a, 0, N);
padic_poly_init2(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_randtest(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_mul(c, b, c, ctx);
result = (padic_poly_equal(a, c) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (aliasing a and c):\n");
padic_poly_print(a, ctx), flint_printf("\n\n");
padic_poly_print(c, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
/* Check (b * c) + (b * d) = b * (c + d) */
for (i = 0; i < 1000; i++)
{
padic_poly_t a1, a2, b, c, d, t;
slong v;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN)
+ PADIC_TEST_PREC_MIN;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_init2(d, 0, N);
padic_poly_init2(t, 0, N);
padic_poly_randtest(b, state, n_randint(state, 100), ctx);
padic_poly_randtest(c, state, n_randint(state, 100), ctx);
padic_poly_randtest(d, state, n_randint(state, 100), ctx);
v = FLINT_MIN(b->val, c->val);
v = FLINT_MIN(v, d->val);
v = FLINT_MIN(v, 0);
if (v >= 0 || -v < N) /* Otherwise, no precision left */
{
slong N2 = (v >= 0) ? N : N + v;
padic_poly_init2(a1, 0, N2);
padic_poly_init2(a2, 0, N2);
padic_poly_mul(a1, b, c, ctx);
padic_poly_mul(t, b, d, ctx);
padic_poly_add(a1, a1, t, ctx); /* Lower precision */
padic_poly_add(t, c, d, ctx);
padic_poly_mul(a2, b, t, ctx); /* Lower precision */
result = (padic_poly_equal(a1, a2) && padic_poly_is_reduced(a1, ctx));
if (!result)
{
flint_printf("FAIL (distributivity):\n");
flint_printf("p = "), fmpz_print(ctx->p), flint_printf("\n\n");
flint_printf("N = %wd\n\n", N);
flint_printf("b = "), padic_poly_print(b, ctx), flint_printf("\n\n");
flint_printf("c = "), padic_poly_print(c, ctx), flint_printf("\n\n");
flint_printf("d = "), padic_poly_print(d, ctx), flint_printf("\n\n");
flint_printf("a1 = "), padic_poly_print(a1, ctx), flint_printf("\n\n");
flint_printf("a2 = "), padic_poly_print(a2, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a1);
padic_poly_clear(a2);
}
padic_poly_clear(b);
padic_poly_clear(c);
padic_poly_clear(d);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
/* Compare with Q */
for (i = 0; i < 10000; i++)
{
padic_poly_t a, b, c, d;
fmpq_poly_t x, y, z;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN)
+ PADIC_TEST_PREC_MIN;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(a, 0, N);
padic_poly_init2(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_init2(d, 0, N);
fmpq_poly_init(x);
fmpq_poly_init(y);
fmpq_poly_init(z);
padic_poly_randtest(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_get_fmpq_poly(y, b, ctx);
padic_poly_get_fmpq_poly(z, c, ctx);
fmpq_poly_mul(x, y, z);
padic_poly_set_fmpq_poly(d, x, ctx);
result = (padic_poly_equal(a, d) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (cmp with Q):\n");
flint_printf("N = %wd, val(b) = %wd, val(c) = %wd\n", N, b->val, c->val);
padic_poly_print(c, ctx), flint_printf("\n\n");
padic_poly_print(d, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_poly_clear(d);
fmpq_poly_clear(x);
fmpq_poly_clear(y);
fmpq_poly_clear(z);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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("evaluate_vec_fast....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
long i, n, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t F;
fmpq * X, * Y;
fmpcb_poly_t f;
fmpcb_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);
fmpcb_poly_init(f);
x = _fmpcb_vec_init(n);
y = _fmpcb_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);
fmpcb_poly_set_fmpq_poly(f, F, rbits1);
for (i = 0; i < n; i++)
fmpcb_set_fmpq(x + i, X + i, rbits2);
fmpcb_poly_evaluate_vec_fast(y, f, x, n, rbits3);
for (i = 0; i < n; i++)
{
if (!fmpcb_contains_fmpq(y + i, Y + i))
{
printf("FAIL (%ld of %ld)\n\n", i, n);
printf("F = "); fmpq_poly_print(F); printf("\n\n");
printf("X = "); fmpq_print(X + i); printf("\n\n");
printf("Y = "); fmpq_print(Y + i); printf("\n\n");
printf("f = "); fmpcb_poly_printd(f, 15); printf("\n\n");
printf("x = "); fmpcb_printd(x + i, 15); printf("\n\n");
printf("y = "); fmpcb_printd(y + i, 15); printf("\n\n");
abort();
}
}
fmpq_poly_clear(F);
_fmpq_vec_clear(X, n);
_fmpq_vec_clear(Y, n);
fmpcb_poly_clear(f);
_fmpcb_vec_clear(x, n);
_fmpcb_vec_clear(y, n);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("mullow....");
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(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");
flint_abort();
}
acb_poly_set(d, a);
acb_poly_mullow(d, d, b, trunc, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
flint_abort();
}
acb_poly_set(d, b);
acb_poly_mullow(d, a, d, trunc, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
flint_abort();
}
/* test squaring */
acb_poly_set(b, a);
acb_poly_mullow(c, a, b, trunc, rbits3);
acb_poly_mullow(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");
flint_abort();
}
acb_poly_mullow(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");
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);
}
/* 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(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");
flint_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()
{
slong iter;
flint_rand_t state;
flint_printf("sqrt_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000; iter++)
{
slong m, n, qbits, rbits1, rbits2;
fmpq_poly_t A;
acb_poly_t a, b, c;
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);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
fmpq_poly_randtest_not_zero(A, state, m, qbits);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_sqrt_series(b, a, n, rbits2);
/* Check sqrt(a)^2 = a */
acb_poly_mullow(c, b, b, n, rbits2);
fmpq_poly_truncate(A, n);
if (!acb_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 = "); 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_sqrt_series(a, a, n, rbits2);
if (!acb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(A);
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()
{
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(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()
{
long iter;
flint_rand_t state;
printf("inv_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
long m, n, qbits, rbits1, rbits2;
fmpq_poly_t A, B;
fmpcb_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, 20);
n = 1 + n_randint(state, 20);
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpcb_poly_init(a);
fmpcb_poly_init(b);
do {
fmpq_poly_randtest_not_zero(A, state, m, qbits);
} while (A->coeffs[0] == 0);
fmpq_poly_inv_series(B, A, n);
fmpcb_poly_set_fmpq_poly(a, A, rbits1);
fmpcb_poly_inv_series(b, a, n, rbits2);
if (!fmpcb_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 = "); fmpcb_poly_printd(a, 15); printf("\n\n");
printf("b = "); fmpcb_poly_printd(b, 15); printf("\n\n");
abort();
}
fmpcb_poly_inv_series(a, a, n, rbits2);
if (!fmpcb_poly_equal(a, b))
{
printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpcb_poly_clear(a);
fmpcb_poly_clear(b);
}
/* check f * f^-1 = 1 */
for (iter = 0; iter < 10000; iter++)
{
long bits, trunc;
fmpcb_poly_t a, b, ab;
fmpq_poly_t id;
bits = 2 + n_randint(state, 200);
trunc = 1 + n_randint(state, 10);
fmpcb_poly_init(a);
fmpcb_poly_init(b);
fmpcb_poly_init(ab);
fmpq_poly_init(id);
do {
fmpcb_poly_randtest(a, state, 1 + n_randint(state, 10), bits, 5);
} while (a->length == 0 || fmpcb_contains_zero(a->coeffs + 0));
fmpcb_poly_inv_series(b, a, trunc, bits);
fmpcb_poly_mullow(ab, a, b, trunc, bits);
fmpq_poly_set_ui(id, 1);
if (!fmpcb_poly_contains_fmpq_poly(ab, id))
{
printf("FAIL\n\n");
printf("bits = %ld\n", bits);
printf("trunc = %ld\n", trunc);
printf("a = "); fmpcb_poly_printd(a, 15); printf("\n\n");
printf("b = "); fmpcb_poly_printd(b, 15); printf("\n\n");
printf("ab = "); fmpcb_poly_printd(ab, 15); printf("\n\n");
abort();
}
fmpcb_poly_clear(a);
fmpcb_poly_clear(b);
fmpcb_poly_clear(ab);
}
flint_randclear(state);
flint_cleanup();
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;
}
void
fmpq_poly_compose_series_horner(fmpq_poly_t res,
const fmpq_poly_t poly1, const fmpq_poly_t poly2, long n)
{
long len1 = poly1->length;
long len2 = poly2->length;
long lenr;
if (len2 != 0 && !fmpz_is_zero(poly2->coeffs))
{
printf("exception: fmpq_poly_compose_series_horner: inner polynomial "
"must have zero constant term\n");
abort();
}
if (len1 == 0 || n == 0)
{
fmpq_poly_zero(res);
return;
}
if (len2 == 0 || len1 == 1)
{
fmpq_poly_fit_length(res, 1);
fmpz_set(res->coeffs, poly1->coeffs);
fmpz_set(res->den, poly1->den);
{
fmpz_t d;
fmpz_init(d);
fmpz_gcd(d, res->coeffs, res->den);
if (!fmpz_is_one(d))
{
fmpz_divexact(res->coeffs, res->coeffs, d);
fmpz_divexact(res->den, res->den, d);
}
fmpz_clear(d);
}
_fmpq_poly_set_length(res, 1);
_fmpq_poly_normalise(res);
return;
}
lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n);
len1 = FLINT_MIN(len1, lenr);
len2 = FLINT_MIN(len2, lenr);
if ((res != poly1) && (res != poly2))
{
fmpq_poly_fit_length(res, lenr);
_fmpq_poly_compose_series_horner(res->coeffs, res->den,
poly1->coeffs, poly1->den, len1,
poly2->coeffs, poly2->den, len2, lenr);
_fmpq_poly_set_length(res, lenr);
_fmpq_poly_normalise(res);
}
else
{
fmpq_poly_t t;
fmpq_poly_init2(t, lenr);
_fmpq_poly_compose_series_horner(t->coeffs, t->den,
poly1->coeffs, poly1->den, len1,
poly2->coeffs, poly2->den, len2, lenr);
_fmpq_poly_set_length(t, lenr);
_fmpq_poly_normalise(t);
fmpq_poly_swap(res, t);
fmpq_poly_clear(t);
}
}
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()
{
long iter;
flint_rand_t state;
printf("evaluate....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
long qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t F;
fmpq_t X, Y;
acb_poly_t f;
acb_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);
acb_poly_init(f);
acb_init(x);
acb_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);
acb_poly_set_fmpq_poly(f, F, rbits1);
acb_set_fmpq(x, X, rbits2);
acb_poly_evaluate(y, f, x, rbits3);
if (!acb_contains_fmpq(y, Y))
{
printf("FAIL\n\n");
printf("F = "); fmpq_poly_print(F); printf("\n\n");
printf("X = "); fmpq_print(X); printf("\n\n");
printf("Y = "); fmpq_print(Y); printf("\n\n");
printf("f = "); acb_poly_printd(f, 15); printf("\n\n");
printf("x = "); acb_printd(x, 15); printf("\n\n");
printf("y = "); acb_printd(y, 15); printf("\n\n");
abort();
}
/* aliasing */
acb_poly_evaluate(x, f, x, rbits3);
if (!acb_contains_fmpq(x, Y))
{
printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(F);
fmpq_clear(X);
fmpq_clear(Y);
acb_poly_clear(f);
acb_clear(x);
acb_clear(y);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("revert_series_newton....");
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_newton(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_newton(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(void)
{
int i, result;
ulong cflags = 0UL;
flint_rand_t state;
printf("scalar_div_fmpq....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 10000; 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)
{
printf("FAIL (aliasing):\n\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_print(z), printf("\n\n");
printf("cflags = %lu\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 < 10000; 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)
{
printf("FAIL (a / n1 / n2):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_print(z1), printf("\n\n");
fmpq_print(z2), printf("\n\n");
fmpq_print(z), printf("\n\n");
fmpq_poly_debug(lhs), printf("\n\n");
fmpq_poly_debug(rhs), printf("\n\n");
printf("cflags = %lu\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 < 10000; 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)
{
printf("FAIL ((a + b) / n):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_print(z), printf("\n\n");
fmpq_poly_debug(lhs), printf("\n\n");
fmpq_poly_debug(rhs), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_clear(z);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("divrem....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
slong m, n, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t A, B, Q, R;
acb_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);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(q);
acb_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);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_divrem(q, r, a, b, rbits3);
if (!acb_poly_contains_fmpq_poly(q, Q) ||
!acb_poly_contains_fmpq_poly(r, R))
{
flint_printf("FAIL\n\n");
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n");
flint_printf("Q = "); fmpq_poly_print(Q); flint_printf("\n\n");
flint_printf("R = "); fmpq_poly_print(R); 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("q = "); acb_poly_printd(q, 15); flint_printf("\n\n");
flint_printf("r = "); acb_poly_printd(r, 15); flint_printf("\n\n");
abort();
}
acb_poly_divrem(a, r, a, b, rbits3);
if (!acb_poly_equal(a, q))
{
flint_printf("FAIL (aliasing q, a)\n\n");
}
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_divrem(b, r, a, b, rbits3);
if (!acb_poly_equal(b, q))
{
flint_printf("FAIL (aliasing q, b)\n\n");
abort();
}
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_divrem(q, a, a, b, rbits3);
if (!acb_poly_equal(a, r))
{
flint_printf("FAIL (aliasing r, a)\n\n");
abort();
}
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_divrem(q, b, a, b, rbits3);
if (!acb_poly_equal(b, r))
{
flint_printf("FAIL (aliasing r, b)\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(Q);
fmpq_poly_clear(R);
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(q);
acb_poly_clear(r);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void fmpq_poly_divrem(fmpq_poly_t Q, fmpq_poly_t R,
const fmpq_poly_t poly1, const fmpq_poly_t poly2)
{
slong lenA, lenB, lenQ, lenR;
if (fmpq_poly_is_zero(poly2))
{
flint_printf("Exception (fmpq_poly_divrem). Division by zero.\n");
abort();
}
if (Q == R)
{
flint_printf("Exception (fmpq_poly_divrem). Output arguments aliased.\n");
abort();
}
/* Deal with the various other cases of aliasing. */
if (R == poly1 || R == poly2)
{
if (Q == poly1 || Q == poly2)
{
fmpq_poly_t tempQ, tempR;
fmpq_poly_init(tempQ);
fmpq_poly_init(tempR);
fmpq_poly_divrem(tempQ, tempR, poly1, poly2);
fmpq_poly_swap(Q, tempQ);
fmpq_poly_swap(R, tempR);
fmpq_poly_clear(tempQ);
fmpq_poly_clear(tempR);
return;
}
else
{
fmpq_poly_t tempR;
fmpq_poly_init(tempR);
fmpq_poly_divrem(Q, tempR, poly1, poly2);
fmpq_poly_swap(R, tempR);
fmpq_poly_clear(tempR);
return;
}
}
else
{
if (Q == poly1 || Q == poly2)
{
fmpq_poly_t tempQ;
fmpq_poly_init(tempQ);
fmpq_poly_divrem(tempQ, R, poly1, poly2);
fmpq_poly_swap(Q, tempQ);
fmpq_poly_clear(tempQ);
return;
}
}
if (poly1->length < poly2->length)
{
fmpq_poly_set(R, poly1);
fmpq_poly_zero(Q);
return;
}
lenA = poly1->length;
lenB = poly2->length;
lenQ = lenA - lenB + 1;
lenR = lenB - 1;
fmpq_poly_fit_length(Q, lenQ);
fmpq_poly_fit_length(R, lenA); /* XXX: Need at least that much space */
_fmpq_poly_divrem(Q->coeffs, Q->den, R->coeffs, R->den,
poly1->coeffs, poly1->den, poly1->length,
poly2->coeffs, poly2->den, poly2->length, NULL);
_fmpq_poly_set_length(Q, lenQ);
_fmpq_poly_set_length(R, lenR);
_fmpq_poly_normalise(R);
}