int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("swap....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
fmpz_poly_set(c, b);
fmpz_poly_swap(a, b);
result = (fmpz_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int iter;
FLINT_TEST_INIT(state);
flint_printf("sgn_eval_at_half....");
fflush(stdout);
/* Check aliasing */
for (iter = 0; iter < 1000 * flint_test_multiplier(); iter++)
{
fmpz_t a;
fmpz_poly_t f, g;
long i, d;
int s1, s2;
fmpz_init(a);
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(f, state, n_randint(state, 100), 200);
s1 = fmpz_poly_sgn_eval_at_half(f);
fmpz_poly_set(g, f);
d = fmpz_poly_degree(g);
for (i = 0; i <= d; i++)
{
fmpz_mul_2exp(fmpz_poly_get_coeff_ptr(g, i),
fmpz_poly_get_coeff_ptr(g, i), d - i);
}
fmpz_one(a);
fmpz_poly_evaluate_fmpz(a, g, a);
s2 = fmpz_sgn(a);
if (s1 != s2)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f); printf("\n\n");
printf("s1 = %d, s2 = %d\n\n", s1, s2);
abort();
}
fmpz_clear(a);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_mod....");
fflush(stdout);
flint_randinit(state);
/* Compare with evaluation over the integers */
for (i = 0; i < 10000; i++)
{
fmpz_t b, s;
fmpz_poly_t f;
mp_limb_t a, n, r;
fmpz_poly_init(f);
fmpz_poly_randtest(f, state, n_randint(state, 10), 20);
n = n_randtest_not_zero(state);
a = n_randint(state, n);
fmpz_init(b);
fmpz_init(s);
fmpz_set_ui(b, a);
r = fmpz_poly_evaluate_mod(f, a, n);
fmpz_poly_evaluate_fmpz(s, f, b);
result = (r == fmpz_mod_ui(s, s, n));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(f), printf("\n\n");
gmp_printf("a = %Mu\n\n", a);
gmp_printf("n = %Mu\n\n", n);
gmp_printf("r = %Mu\n\n", r);
printf("s = "), fmpz_print(s), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_clear(b);
fmpz_clear(s);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("get_coeff_ptr....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t A;
fmpz_t a;
slong n = n_randint(state, 100);
fmpz_poly_init(A);
fmpz_poly_randtest(A, state, n_randint(state, 100), 100);
fmpz_init(a);
fmpz_poly_get_coeff_fmpz(a, A, n);
result = n < fmpz_poly_length(A) ?
fmpz_equal(a, fmpz_poly_get_coeff_ptr(A, n)) :
fmpz_poly_get_coeff_ptr(A, n) == NULL;
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A = "), fmpz_poly_print(A), flint_printf("\n\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n\n");
flint_printf("n = %wd\n\n", n);
abort();
}
fmpz_poly_clear(A);
fmpz_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("gcd....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 500; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 40), 80);
fmpz_poly_randtest(c, state, n_randint(state, 40), 80);
fmpz_poly_gcd(a, b, c);
fmpz_poly_gcd(b, b, c);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL (aliasing a and b):\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 500; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 40), 80);
fmpz_poly_randtest(c, state, n_randint(state, 40), 80);
fmpz_poly_gcd(a, b, c);
fmpz_poly_gcd(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
printf("FAIL (aliasing a and c):\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(c), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check that a divides GCD(af, ag) */
for (i = 0; i < 500; i++)
{
fmpz_poly_t a, d, f, g, q, r;
fmpz_poly_init(a);
fmpz_poly_init(d);
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest_not_zero(a, state, n_randint(state, 24) + 1, 24);
fmpz_poly_randtest(f, state, n_randint(state, 40), 80);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_mul(f, a, f);
fmpz_poly_mul(g, a, g);
fmpz_poly_gcd(d, f, g);
fmpz_poly_divrem_divconquer(q, r, d, a);
result = (r->length == 0L);
if (!result)
{
printf("FAIL (check a | gcd(af, ag)):\n");
fmpz_poly_print(f), printf("\n");
fmpz_poly_print(g), printf("\n");
fmpz_poly_print(d), printf("\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(d);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sqrlow_KS....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b;
slong len, trunc;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
len = 2 * b->length - 1;
trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length);
fmpz_poly_sqrlow_KS(a, b, trunc);
fmpz_poly_sqrlow_KS(b, b, trunc);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
/* Compare with sqr_KS */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
slong len, trunc;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
len = 2 * b->length - 1;
trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length - 1);
fmpz_poly_sqr_KS(a, b);
fmpz_poly_truncate(a, trunc);
fmpz_poly_sqrlow_KS(c, b, trunc);
result = (fmpz_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pow_ui_trunc_binexp....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpz_poly */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong zbits1, rbits1, rbits2, trunc;
ulong e;
fmpz_poly_t A, B;
acb_poly_t a, b;
zbits1 = 2 + n_randint(state, 100);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
e = n_randint(state, 50);
trunc = n_randint(state, 40);
fmpz_poly_init(A);
fmpz_poly_init(B);
acb_poly_init(a);
acb_poly_init(b);
fmpz_poly_randtest(A, state, 1 + n_randint(state, 10), zbits1);
fmpz_poly_pow_trunc(B, A, e, trunc);
acb_poly_set_fmpz_poly(a, A, rbits1);
acb_poly_pow_ui_trunc_binexp(b, a, e, trunc, rbits2);
if (!acb_poly_contains_fmpz_poly(b, B))
{
flint_printf("FAIL\n\n");
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("e = %wu\n", e);
flint_printf("trunc = %wd\n", trunc);
flint_printf("A = "); fmpz_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpz_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_pow_ui_trunc_binexp(a, a, e, trunc, rbits2);
if (!acb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpz_poly_clear(A);
fmpz_poly_clear(B);
acb_poly_clear(a);
acb_poly_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main() {
slong n = 7;
fmpz_t mod;
fmpz* xs = _fmpz_vec_init(n);
fmpz* ys = _fmpz_vec_init(n);
fmpz_mod_poly_t res;
fmpz_poly_t res2;
fmpz_init(mod);
fmpz_set_ui(mod, 11);
fmpz_set_ui(xs, 0);
fmpz_set_ui(xs+1, 1);
fmpz_set_ui(xs+2, 2);
fmpz_set_ui(xs+3, 3);
fmpz_set_ui(xs+4, 4);
fmpz_set_ui(xs+5, 5);
fmpz_set_ui(xs+6, 6);
fmpz_set_si(ys, 5);
fmpz_set_si(ys+1, 1);
fmpz_set_si(ys+2, 4);
fmpz_set_si(ys+3, 8);
fmpz_set_si(ys+4, 4);
fmpz_set_si(ys+5, 1);
fmpz_set_si(ys+6, 5);
printf("xs :\n");
_fmpz_vec_print(xs,n);
printf("\n");
printf("ys :\n");
_fmpz_vec_print(ys,n);
printf("\n");
fmpz_mod_poly_init(res,mod);
fmpz_mod_poly_interpolate_fmpz_vec_fast(res, xs, ys, n, mod);
fmpz_poly_init(res2);
fmpz_poly_interpolate_fmpz_vec(res2, xs, ys, n);
printf("Nouvelle interpolation (f(xs) = ys) :\n");
fmpz_mod_poly_print(res);
printf("\n");
fmpz* zs = _fmpz_vec_init(n);
fmpz_poly_evaluate_fmpz_vec(zs, res2, xs, n);
fmpz* as = _fmpz_vec_init(n);
fmpz_mod_poly_evaluate_fmpz_vec(as, res, xs, n);
printf("f(xs) :\n");
_fmpz_vec_print(as,n);
printf("\n");
printf("FLINT :\n");
fmpz_poly_print(res2);
printf("\n");
printf("f(xs) :\n");
_fmpz_vec_print(zs,n);
printf("\n");
fmpz_clear(mod);
_fmpz_vec_clear(xs,n);
_fmpz_vec_clear(ys,n);
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mul_karatsuba....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_karatsuba(a, b, c);
fmpz_poly_mul_karatsuba(b, b, c);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_karatsuba(a, b, c);
fmpz_poly_mul_karatsuba(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Compare with mul_classical */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c, d;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(d);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_karatsuba(a, b, c);
fmpz_poly_mul_classical(d, b, c);
result = (fmpz_poly_equal(a, d));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(d), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(d);
}
/* Check _fmpz_poly_mul_karatsuba directly */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
slong len1, len2;
fmpz_poly_t a, b, out1, out2;
len1 = n_randint(state, 100) + 1;
len2 = n_randint(state, 100) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(out1);
fmpz_poly_init(out2);
fmpz_poly_randtest(a, state, len1, 200);
fmpz_poly_randtest(b, state, len2, 200);
fmpz_poly_mul_karatsuba(out1, a, b);
fmpz_poly_fit_length(a, a->alloc + n_randint(state, 10));
fmpz_poly_fit_length(b, b->alloc + n_randint(state, 10));
a->length = a->alloc;
b->length = b->alloc;
fmpz_poly_fit_length(out2, a->length + b->length - 1);
if (a->length >= b->length)
_fmpz_poly_mul_karatsuba(out2->coeffs, a->coeffs, a->length,
b->coeffs, b->length);
else
_fmpz_poly_mul_karatsuba(out2->coeffs, b->coeffs, b->length,
a->coeffs, a->length);
_fmpz_poly_set_length(out2, a->length + b->length - 1);
_fmpz_poly_normalise(out2);
result = (fmpz_poly_equal(out1, out2));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(out1), flint_printf("\n\n");
fmpz_poly_print(out2), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(out1);
fmpz_poly_clear(out2);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("mul_KS....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_KS(a, b, c);
fmpz_poly_mul_KS(b, b, c);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_KS(a, b, c);
fmpz_poly_mul_KS(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(c), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_set(c, b);
fmpz_poly_mul_KS(a, b, b);
fmpz_poly_mul_KS(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(c), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Compare with mul_classical */
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a, b, c, d;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(d);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_KS(a, b, c);
fmpz_poly_mul_classical(d, b, c);
result = (fmpz_poly_equal(a, d));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(d), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(d);
}
/* Compare with mul_classical unsigned */
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a, b, c, d;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(d);
fmpz_poly_randtest_unsigned(b, state, n_randint(state, 50), 200);
fmpz_poly_randtest_unsigned(c, state, n_randint(state, 50), 200);
fmpz_poly_mul_KS(a, b, c);
fmpz_poly_mul_classical(d, b, c);
result = (fmpz_poly_equal(a, d));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(d), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(d);
}
/* Check _fmpz_poly_mul_KS directly */
for (i = 0; i < 2000; i++)
{
long len1, len2;
fmpz_poly_t a, b, out1, out2;
len1 = n_randint(state, 100) + 1;
len2 = n_randint(state, 100) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(out1);
fmpz_poly_init(out2);
fmpz_poly_randtest(a, state, len1, 200);
fmpz_poly_randtest(b, state, len2, 200);
fmpz_poly_mul_KS(out1, a, b);
fmpz_poly_fit_length(a, a->alloc + n_randint(state, 10));
fmpz_poly_fit_length(b, b->alloc + n_randint(state, 10));
a->length = a->alloc;
b->length = b->alloc;
fmpz_poly_fit_length(out2, a->length + b->length - 1);
_fmpz_poly_mul_KS(out2->coeffs, a->coeffs, a->length,
b->coeffs, b->length);
_fmpz_poly_set_length(out2, a->length + b->length - 1);
_fmpz_poly_normalise(out2);
result = (fmpz_poly_equal(out1, out2));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(out1), printf("\n\n");
fmpz_poly_print(out2), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(out1);
fmpz_poly_clear(out2);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("CRT_ui_unsigned....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
long bits, prime_bits, length, num_primes, j;
fmpz_t mod;
fmpz_poly_t A, B, C;
nmod_poly_t Amod;
mp_limb_t primes[1000];
bits = n_randint(state, 500) + 1;
length = n_randint(state, 30) + 1;
prime_bits = 1 + n_randint(state, FLINT_BITS - 1);
fmpz_poly_init(A);
fmpz_poly_init(B);
fmpz_poly_init(C);
fmpz_poly_randtest_unsigned(A, state, length, bits);
fmpz_init(mod);
num_primes = 0;
primes[0] = n_nextprime(1UL << prime_bits, 0);
fmpz_set_ui(mod, primes[0]);
while (fmpz_bits(mod) <= bits)
{
primes[num_primes + 1] = n_nextprime(primes[num_primes], 0);
fmpz_mul_ui(mod, mod, primes[num_primes + 1]);
num_primes++;
}
num_primes++;
nmod_poly_init(Amod, primes[0]);
fmpz_poly_get_nmod_poly(Amod, A);
fmpz_poly_set_nmod_poly_unsigned(B, Amod);
fmpz_set_ui(mod, primes[0]);
for (j = 1; j < num_primes; j++)
{
nmod_poly_clear(Amod);
nmod_poly_init(Amod, primes[j]);
fmpz_poly_get_nmod_poly(Amod, A);
fmpz_poly_CRT_ui(B, B, mod, Amod, 0);
fmpz_mul_ui(mod, mod, primes[j]);
}
if (!fmpz_poly_equal(B, A))
{
printf("FAIL!\n");
printf("primes: ");
for (j = 0; j < num_primes; j++)
printf("%lu ", primes[j]);
printf("\nA: \n");
fmpz_poly_print(A);
printf("\nB: \n");
fmpz_poly_print(B);
printf("\n");
abort();
}
nmod_poly_clear(Amod);
fmpz_poly_clear(A);
fmpz_poly_clear(B);
fmpz_poly_clear(C);
fmpz_clear(mod);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
poly_draw(const fmpz_poly_t poly)
{
fmpz_poly_print(poly);
flint_printf("\n");
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("set_si_equal....");
fflush(stdout);
/* equal polynomials */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b;
slong n;
fmpz_poly_init(a);
fmpz_poly_init(b);
n = z_randtest(state);
fmpz_poly_set_si(a, n);
fmpz_poly_set(b, a);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wd\n\n", n);
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b;
slong m, n;
fmpz_poly_init(a);
fmpz_poly_init(b);
m = z_randtest(state);
n = z_randtest(state);
while (m == n)
n = z_randtest(state);
fmpz_poly_set_si(a, m);
fmpz_poly_set_si(b, n);
result = (!fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("m = %wd\n\n", m);
flint_printf("n = %wd\n\n", n);
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(int argc, char *args[])/* setup.txt, ct.txt{ct->lev, ct->row, ct->col, ct}, sk.txt{row, col, poly}*/
{
FILE *fp;
if((fp = fopen(args[1], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
fmpz_t tmp;
fmpz_init(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
long lev, d, i, j;
lev = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
d = fmpz_get_si(tmp);
fmpz_poly_t fx;
fmpz_poly_init(fx);
fmpz_poly_set_coeff_si(fx, 0, 1);
fmpz_poly_set_coeff_si(fx, d, 1);
param_node_t *ph, *pr, *ps, *param;
ph = param_node_init(ph);
ps = ph;
for( i = 0 ; i <= lev; i++ ) {
pr = param_node_init(pr);
fgets(str, 100, fp);
fmpz_set_str(pr->q, str, 10);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
pr->n = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
pr->bign = fmpz_get_si(tmp);
ps->next = pr;
ps = pr;
}
ps->next = NULL;
fclose(fp);
param = ph->next;
long row, col, ctlev;
if((fp = fopen(args[2], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
ctlev = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
row = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
col = fmpz_get_si(tmp);
fmpz_poly_mat_t ct;
fmpz_poly_mat_init(ct, row, col);
for( i = 0 ; i < row ; i++) {
for(j = 0; j < col ; j++) {
fgets(str, 100000, fp);
fmpz_poly_set_str(fmpz_poly_mat_entry(ct, i, j), str);
}
}
fclose(fp);
if((fp = fopen(args[3], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
long l;
sk_node_t *sh, *ss, *sr;
sh = (sk_node_t *)malloc(sizeof(sk_node_t));
ss = sh;
for(l = 0; l <= lev ; l++){
sr = (sk_node_t *)malloc(sizeof(sk_node_t));
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
row = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
col = fmpz_get_si(tmp);
fmpz_poly_mat_init(sr->sk, row, col);
for( i = 0 ; i < row ; i++) {
for(j = 0; j < col ; j++) {
fgets(str, 100000, fp);
fmpz_poly_set_str(fmpz_poly_mat_entry(sr->sk, i, j), str);
}
}
ss->next = sr;
ss = sr;
}
ss->next = NULL;
fclose(fp);
sh = sh->next;
while(lev > ctlev){
sh = sh->next;
param = param->next;
lev--;
}
fmpz_poly_t ms;
fmpz_poly_init(ms);
e_decrypt(ms, param, sh->sk, ct, fx);
fmpz_poly_print(ms);
printf("\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("pow_multinomial....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
ulong exp;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 10), 100);
exp = n_randtest(state) % 20UL;
fmpz_poly_pow_multinomial(a, b, exp);
fmpz_poly_pow_multinomial(b, b, exp);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL(1):\n");
printf("exp = %lu\n", exp);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
/* Compare with fmpz_poly_pow */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
ulong exp;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 10), 100);
exp = n_randtest(state) % 20UL;
fmpz_poly_pow_multinomial(a, b, exp);
fmpz_poly_pow(b, b, exp);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL(2):\n");
printf("exp = %lu\n", exp);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("revert_series_lagrange_fast....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_revert_series_lagrange_fast(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
flint_printf("FAIL (comparison):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("divrem_basecase....");
fflush(stdout);
flint_randinit(state);
/* Check q*b + r = a, no aliasing */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, q, r, prod;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_init(prod);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_mul(prod, q, b);
fmpz_poly_add(prod, prod, r);
result = (fmpz_poly_equal(a, prod));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(prod), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
fmpz_poly_clear(prod);
}
/* Check r and a alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(q, a, a, b);
result = (fmpz_poly_equal(a, r));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check r and b alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(q, b, a, b);
result = (fmpz_poly_equal(b, r));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check q and a alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(a, r, a, b);
result = (fmpz_poly_equal(a, q));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check q and b alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(b, r, a, b);
result = (fmpz_poly_equal(b, q));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("hensel_start_continue_lift....");
fflush(stdout);
flint_randinit(state);
/* We check that lifting local factors of F yields factors */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t F, G, H, R;
nmod_poly_factor_t f_fac;
fmpz_poly_factor_t F_fac;
long bits, nbits, n, exp, j, part_exp;
long r;
fmpz_poly_t *v, *w;
long *link;
long prev_exp;
bits = n_randint(state, 200) + 1;
nbits = n_randint(state, FLINT_BITS - 6) + 6;
fmpz_poly_init(F);
fmpz_poly_init(G);
fmpz_poly_init(H);
fmpz_poly_init(R);
nmod_poly_factor_init(f_fac);
fmpz_poly_factor_init(F_fac);
n = n_randprime(state, nbits, 0);
exp = bits / (FLINT_BIT_COUNT(n) - 1) + 1;
part_exp = n_randint(state, exp);
/* Produce F as the product of random G and H */
{
nmod_poly_t f;
nmod_poly_init(f, n);
do {
do {
fmpz_poly_randtest(G, state, n_randint(state, 200) + 2, bits);
} while (G->length < 2);
fmpz_randtest_not_zero(G->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(G));
do {
fmpz_poly_randtest(H, state, n_randint(state, 200) + 2, bits);
} while (H->length < 2);
fmpz_randtest_not_zero(H->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(H));
fmpz_poly_mul(F, G, H);
fmpz_poly_get_nmod_poly(f, F);
} while (!nmod_poly_is_squarefree(f));
fmpz_poly_get_nmod_poly(f, G);
nmod_poly_factor_insert(f_fac, f, 1);
fmpz_poly_get_nmod_poly(f, H);
nmod_poly_factor_insert(f_fac, f, 1);
nmod_poly_clear(f);
}
r = f_fac->num;
v = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
w = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
link = flint_malloc((2*r - 2)*sizeof(long));
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_init(v[j]);
fmpz_poly_init(w[j]);
}
if (part_exp < 1)
{
_fmpz_poly_hensel_start_lift(F_fac, link, v, w, F, f_fac, exp);
}
else
{
fmpz_t nn;
fmpz_init_set_ui(nn, n);
prev_exp = _fmpz_poly_hensel_start_lift(F_fac, link, v, w,
F, f_fac, part_exp);
_fmpz_poly_hensel_continue_lift(F_fac, link, v, w,
F, prev_exp, part_exp, exp, nn);
fmpz_clear(nn);
}
result = 1;
for (j = 0; j < F_fac->num; j++)
{
fmpz_poly_rem(R, F, F_fac->p + j);
result &= (R->length == 0);
}
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_clear(v[j]);
fmpz_poly_clear(w[j]);
}
flint_free(link);
flint_free(v);
flint_free(w);
if (!result)
{
printf("FAIL:\n");
printf("bits = %ld, n = %ld, exp = %ld\n", bits, n, exp);
fmpz_poly_print(F); printf("\n\n");
fmpz_poly_print(G); printf("\n\n");
fmpz_poly_print(H); printf("\n\n");
fmpz_poly_factor_print(F_fac); printf("\n\n");
abort();
}
nmod_poly_factor_clear(f_fac);
fmpz_poly_factor_clear(F_fac);
fmpz_poly_clear(F);
fmpz_poly_clear(H);
fmpz_poly_clear(G);
fmpz_poly_clear(R);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("inv_series_newton....");
fflush(stdout);
/* Check Q^{-1} * Q is congruent 1 mod t^n */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c, one;
slong n = n_randint(state, 80) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(one);
fmpz_poly_randtest_not_zero(a, state, n_randint(state, 80) + 1, 100);
fmpz_poly_set_coeff_si(a, 0, n_randint(state, 2) ? 1 : -1);
fmpz_poly_set_ui(one, 1);
fmpz_poly_inv_series_newton(b, a, n);
fmpz_poly_mullow(c, a, b, n);
result = (fmpz_poly_equal(c, one));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(one);
}
/* Verify bug fix for the case Q = -1 mod (x) */
{
fmpz_poly_t a, b, c, one;
slong n = 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(one);
fmpz_poly_set_si(a, -1);
fmpz_poly_set_ui(one, 1);
fmpz_poly_inv_series_newton(b, a, n);
fmpz_poly_mullow(c, a, b, n);
result = (fmpz_poly_equal(c, one));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(one);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("taylor_shift_divconquer....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g;
fmpz_t c;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_init(c);
fmpz_poly_randtest(f, state, 1 + n_randint(state, 20),
1 + n_randint(state, 200));
fmpz_randtest(c, state, n_randint(state, 200));
fmpz_poly_taylor_shift_divconquer(g, f, c);
fmpz_poly_taylor_shift_divconquer(f, f, c);
if (!fmpz_poly_equal(g, f))
{
flint_printf("FAIL\n");
fmpz_poly_print(f); flint_printf("\n");
fmpz_poly_print(g); flint_printf("\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_clear(c);
}
/* Compare with composition */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h1, h2;
fmpz_t c;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h1);
fmpz_poly_init(h2);
fmpz_init(c);
fmpz_poly_randtest(f, state, 1 + n_randint(state, 20),
1 + n_randint(state, 200));
fmpz_randtest(c, state, n_randint(state, 200));
fmpz_poly_set_coeff_ui(g, 1, 1);
fmpz_poly_set_coeff_fmpz(g, 0, c);
fmpz_poly_taylor_shift_divconquer(h1, f, c);
fmpz_poly_compose(h2, f, g);
if (!fmpz_poly_equal(h1, h2))
{
flint_printf("FAIL\n");
fmpz_poly_print(f); flint_printf("\n");
fmpz_poly_print(g); flint_printf("\n");
fmpz_poly_print(h1); flint_printf("\n");
fmpz_poly_print(h2); flint_printf("\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h1);
fmpz_poly_clear(h2);
fmpz_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("compose_horner....");
fflush(stdout);
/* Check aliasing of the first argument */
for (i = 0; i < 8 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_compose_horner(f, g, h);
fmpz_poly_compose_horner(g, g, h);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
/* Check aliasing of the second argument */
for (i = 0; i < 8 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_compose_horner(f, g, h);
fmpz_poly_compose_horner(h, g, h);
result = (fmpz_poly_equal(f, h));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
/* Compare with the default method */
for (i = 0; i < 8 * flint_test_multiplier(); i++)
{
fmpz_poly_t f1, f2, g, h;
fmpz_poly_init(f1);
fmpz_poly_init(f2);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_compose_horner(f1, g, h);
fmpz_poly_compose(f2, g, h);
result = (fmpz_poly_equal(f1, f2));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f1), flint_printf("\n\n");
fmpz_poly_print(f2), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f1);
fmpz_poly_clear(f2);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_fmpz....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
fmpz_t a, b, p;
fmpz_mod_poly_t f;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_init(a);
fmpz_init(b);
fmpz_randm(a, state, p);
fmpz_mod_poly_init(f, p);
fmpz_mod_poly_randtest(f, state, n_randint(state, 100));
fmpz_mod_poly_evaluate_fmpz(b, f, a);
fmpz_mod_poly_evaluate_fmpz(a, f, a);
result = (fmpz_equal(a, b));
if (!result)
{
printf("FAIL:\n");
fmpz_mod_poly_print(f), printf("\n\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(f);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(p);
}
/* Check that the result agrees with Z[X] */
for (i = 0; i < 10000; i++)
{
fmpz_t a, b, c, p;
fmpz_mod_poly_t f;
fmpz_poly_t g;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_mod_poly_init(f, p);
fmpz_poly_init(g);
fmpz_randm(a, state, p);
fmpz_mod_poly_randtest(f, state, n_randint(state, 100));
fmpz_mod_poly_get_fmpz_poly(g, f);
fmpz_mod_poly_evaluate_fmpz(b, f, a);
fmpz_poly_evaluate_fmpz(c, g, a);
fmpz_mod(c, c, p);
result = (fmpz_equal(b, c));
if (!result)
{
printf("FAIL (cmp with fmpz_poly):\n");
fmpz_mod_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
fmpz_print(c), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(p);
fmpz_mod_poly_clear(f);
fmpz_poly_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("reverse....");
fflush(stdout);
flint_randinit(state);
/* Aliasing */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
long n;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
n = n_randint(state, 150);
fmpz_poly_reverse(a, b, n);
fmpz_poly_reverse(b, b, n);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("n = %ld\n", n);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
/* Correctness (?) */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
long j, len, n;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
n = n_randint(state, 150);
len = FLINT_MIN(n, b->length);
if (len)
{
fmpz_poly_fit_length(a, n);
for (j = 0; j < len; j++)
fmpz_set(a->coeffs + (n - len) + j, b->coeffs + (len - 1 - j));
_fmpz_poly_set_length(a, n);
_fmpz_poly_normalise(a);
}
fmpz_poly_reverse(b, b, n);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("n = %ld\n", n);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("mul....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 500);
fmpz_poly_randtest(c, state, n_randint(state, 50), 500);
fmpz_poly_mul(a, b, c);
fmpz_poly_mul(b, b, c);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 500);
fmpz_poly_randtest(c, state, n_randint(state, 50), 500);
fmpz_poly_mul(a, b, c);
fmpz_poly_mul(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(c), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check (b*c)+(b*d) = b*(c+d) */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a1, a2, b, c, d;
fmpz_poly_init(a1);
fmpz_poly_init(a2);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(d);
fmpz_poly_randtest(b, state, n_randint(state, 100), 500);
fmpz_poly_randtest(c, state, n_randint(state, 100), 500);
fmpz_poly_randtest(d, state, n_randint(state, 100), 500);
fmpz_poly_mul(a1, b, c);
fmpz_poly_mul(a2, b, d);
fmpz_poly_add(a1, a1, a2);
fmpz_poly_add(c, c, d);
fmpz_poly_mul(a2, b, c);
result = (fmpz_poly_equal(a1, a2));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a1), printf("\n\n");
fmpz_poly_print(a2), printf("\n\n");
abort();
}
fmpz_poly_clear(a1);
fmpz_poly_clear(a2);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(d);
}
/* Check _fmpz_poly_mul directly */
for (i = 0; i < 2000; i++)
{
long len1, len2;
fmpz_poly_t a, b, out1, out2;
len1 = n_randint(state, 100) + 1;
len2 = n_randint(state, 100) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(out1);
fmpz_poly_init(out2);
fmpz_poly_randtest(a, state, len1, 200);
fmpz_poly_randtest(b, state, len2, 200);
fmpz_poly_mul(out1, a, b);
fmpz_poly_fit_length(a, a->alloc + n_randint(state, 10));
fmpz_poly_fit_length(b, b->alloc + n_randint(state, 10));
a->length = a->alloc;
b->length = b->alloc;
fmpz_poly_fit_length(out2, a->length + b->length - 1);
if (a->length >= b->length)
_fmpz_poly_mul(out2->coeffs, a->coeffs, a->length,
b->coeffs, b->length);
else
_fmpz_poly_mul(out2->coeffs, b->coeffs, b->length,
a->coeffs, a->length);
_fmpz_poly_set_length(out2, a->length + b->length - 1);
_fmpz_poly_normalise(out2);
result = (fmpz_poly_equal(out1, out2));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(out1), printf("\n\n");
fmpz_poly_print(out2), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(out1);
fmpz_poly_clear(out2);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
check_periods()
{
FILE * fp;
int ip, f, in, im;
int flag = 0;
flint_printf("periods...");
fflush(stdout);
fp = fopen("ref_periods.txt", "r");
if (fp == NULL)
abort();
for (ip = 0; ip < nm; ip++)
{
slong prec = vp[ip];
acb_t ref;
acb_init(ref);
for (f = 0; f < nf; f++)
{
for (in = 0; in < nn; in++)
{
fmpz_poly_t pol;
fmpz_poly_init(pol);
vf[f](pol, vn[in]);
for (im = 0; im < nm; im++)
{
slong c;
abel_jacobi_t aj;
abel_jacobi_init_poly(aj, vm[im], pol);
abel_jacobi_compute(aj, flag, prec);
/* check 4 entries of each matrix */
for (c = 0; c < nc; c++)
{
acb_ptr coeff;
acb_get_file(ref, fp, prec);
coeff = acb_mat_entry(aj->omega0, c % 2, c / 2);
if (!acb_overlaps(ref, coeff))
{
flint_printf("FAIL:\n\n");
flint_printf("pol = ");
fmpz_poly_print(pol);
flint_printf("\nn = %ld, m = %ld, prec = %ld\n", vn[in], vm[im], prec);
flint_printf("\nref = ");
acb_printd(ref, 20);
flint_printf("\nperiod = ");
acb_printd(coeff, 20);
flint_printf("\n\n");
abort();
}
}
abel_jacobi_clear(aj);
}
fmpz_poly_clear(pol);
}
}
acb_clear(ref);
}
fclose(fp);
flint_cleanup();
printf("PASS\n");
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("set_ui_equal....");
fflush(stdout);
flint_randinit(state);
/* equal polynomials */
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a, b;
ulong n;
fmpz_poly_init(a);
fmpz_poly_init(b);
n = n_randtest(state);
fmpz_poly_set_ui(a, n);
fmpz_poly_set(b, a);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("n = %lu\n\n", n);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a, b;
ulong m, n;
fmpz_poly_init(a);
fmpz_poly_init(b);
m = n_randtest(state);
n = n_randtest(state);
while (m == n)
n = n_randtest(state);
fmpz_poly_set_ui(a, m);
fmpz_poly_set_ui(b, n);
result = (!fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("m = %lu\n\n", m);
printf("n = %lu\n\n", n);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("revert_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_revert_series(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
printf("FAIL (aliasing):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g, h;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 10);
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
printf("FAIL (comparison):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_poly_print(h), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("pseudo_div....");
fflush(stdout);
/* Check r = a - q * b has small degree, no aliasing */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, q, r, prod;
fmpz_t p;
ulong d;
fmpz_init(p);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_init(prod);
fmpz_poly_randtest(a, state, n_randint(state, 100), 50);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50);
fmpz_poly_pseudo_div(q, &d, a, b);
fmpz_poly_mul(prod, q, b);
fmpz_pow_ui(p, b->coeffs + b->length - 1, d);
fmpz_poly_scalar_mul_fmpz(a, a, p);
fmpz_poly_sub(r, a, prod);
result = (fmpz_poly_length(r) < fmpz_poly_length(b));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(prod), flint_printf("\n\n");
fmpz_poly_print(q), flint_printf("\n\n");
fmpz_poly_print(r), flint_printf("\n\n");
abort();
}
fmpz_clear(p);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
fmpz_poly_clear(prod);
}
/* Check q and a alias */
for (i = 0; i < 50 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, q;
ulong d;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_randtest(a, state, n_randint(state, 100), 50);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50);
fmpz_poly_pseudo_div(q, &d, a, b);
fmpz_poly_pseudo_div(a, &d, a, b);
result = (fmpz_poly_equal(a, q));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(q), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
}
/* Check q and b alias */
for (i = 0; i < 50 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, q;
ulong d;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_randtest(a, state, n_randint(state, 100), 50);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50);
fmpz_poly_pseudo_div(q, &d, a, b);
fmpz_poly_pseudo_div(b, &d, a, b);
result = (fmpz_poly_equal(b, q));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(q), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_addmul_fmpz....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_set(b, a);
fmpz_poly_set(c, a);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
fmpz_poly_scalar_addmul_fmpz(a, a, x);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL (1):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check that b += x*a is the same as c = b + x*a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
fmpz_poly_scalar_mul_fmpz(c, a, x);
fmpz_poly_add(c, b, c);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
result = (fmpz_poly_equal(b, c));
if (!result)
{
flint_printf("FAIL (2):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("compose_series....");
fflush(stdout);
/* Check aliasing of the first argument */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_set_coeff_ui(h, 0, 0);
n = n_randint(state, 20);
fmpz_poly_compose_series(f, g, h, n);
fmpz_poly_compose_series(g, g, h, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL (aliasing 1):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
/* Check aliasing of the second argument */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_set_coeff_ui(h, 0, 0);
n = n_randint(state, 20);
fmpz_poly_compose_series(f, g, h, n);
fmpz_poly_compose_series(h, g, h, n);
result = (fmpz_poly_equal(f, h));
if (!result)
{
flint_printf("FAIL (aliasing 2):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
/* Compare with compose */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h, s, t;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_init(s);
fmpz_poly_init(t);
fmpz_poly_randtest(g, state, n_randint(state, 40), 80);
fmpz_poly_randtest(h, state, n_randint(state, 20), 50);
fmpz_poly_set_coeff_ui(h, 0, 0);
n = n_randint(state, 10);
fmpz_poly_compose(s, g, h);
fmpz_poly_truncate(s, n);
fmpz_poly_compose_series(f, g, h, n);
result = (fmpz_poly_equal(f, s));
if (!result)
{
flint_printf("FAIL (comparison):\n");
flint_printf("n = %wd\n", n);
flint_printf("g = "), fmpz_poly_print(g), flint_printf("\n\n");
flint_printf("h = "), fmpz_poly_print(h), flint_printf("\n\n");
flint_printf("f = "), fmpz_poly_print(f), flint_printf("\n\n");
flint_printf("s = "), fmpz_poly_print(s), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
fmpz_poly_clear(s);
fmpz_poly_clear(t);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
