/**
* Test error handling of importing public key.
*/
void test_import_public_key2(void)
{
keypair pair;
fmpz_poly_t f, g, pub;
int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
ntru_params params;
fmpz_poly_init(pub);
params.N = 11;
params.p = 3;
params.q = 32;
poly_new(f, f_c, 11);
poly_new(g, g_c, 11);
ntru_create_keypair(&pair, f, g, ¶ms);
export_public_key("pub.key", pair.pub, ¶ms);
import_public_key(pub, "foo", ¶ms);
remove("pub.key");
CU_ASSERT_NOT_EQUAL(1, fmpz_poly_equal(pub, pair.pub));
}
/**
* Test error handling of importing private key.
*/
void test_import_private_key2(void)
{
keypair pair;
fmpz_poly_t f, g, priv, priv_inv;
int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
ntru_params params;
fmpz_poly_init(priv);
fmpz_poly_init(priv_inv);
params.N = 11;
params.p = 3;
params.q = 32;
poly_new(f, f_c, 11);
poly_new(g, g_c, 11);
ntru_create_keypair(&pair, f, g, ¶ms);
export_priv_key("priv.key", pair.priv, ¶ms);
import_priv_key(priv, priv_inv, ".", ¶ms);
remove("priv.key");
CU_ASSERT_NOT_EQUAL(1, fmpz_poly_equal(priv, pair.priv));
}
/**
* Test keypair creation.
*/
void test_create_keypair1(void)
{
keypair pair;
fmpz_poly_t f, g, pub, priv_inv;
int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
int pub_c[] = { 8, 25, 22, 20, 12, 24, 15, 19, 12, 19, 16 };
int priv_inv_c[] = { 1, 2, 0, 2, 2, 1, 0, 2, 1, 2, 0 };
ntru_params params;
params.N = 11;
params.p = 3;
params.q = 32;
poly_new(f, f_c, 11);
poly_new(g, g_c, 11);
poly_new(pub, pub_c, 11);
poly_new(priv_inv, priv_inv_c, 11);
CU_ASSERT_EQUAL(true, ntru_create_keypair(&pair, f, g, ¶ms));
CU_ASSERT_EQUAL(1, fmpz_poly_equal(pub, pair.pub));
CU_ASSERT_EQUAL(1, fmpz_poly_equal(priv_inv, pair.priv_inv));
CU_ASSERT_EQUAL(1, fmpz_poly_equal(f, pair.priv));
}
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()
{
fmpz_poly_t T, U;
slong n;
FLINT_TEST_INIT(state);
flint_printf("chebyshev_u_polynomial....");
fflush(stdout);
fmpz_poly_init(T);
fmpz_poly_init(U);
for (n = 0; n <= 500; n++)
{
arith_chebyshev_u_polynomial(U, n);
arith_chebyshev_t_polynomial(T, n + 1);
fmpz_poly_derivative(T, T);
fmpz_poly_scalar_divexact_ui(T, T, n + 1);
if (!fmpz_poly_equal(T, U))
{
flint_printf("FAIL: n = %wd\n", n);
flint_printf("T: "); fmpz_poly_print_pretty(T, "x"); flint_printf("\n");
flint_printf("U: "); fmpz_poly_print_pretty(U, "x"); flint_printf("\n");
abort();
}
}
fmpz_poly_clear(T);
fmpz_poly_clear(U);
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, 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_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_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("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("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_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;
}
int
main(void)
{
flint_rand_t state;
long i;
printf("inv....");
fflush(stdout);
flint_randinit(state);
/* Test aliasing */
for (i = 0; i < 400; i++)
{
fmpz_poly_mat_t A, Ainv;
fmpz_poly_t den1, den2;
long n, bits, deg;
float density;
int ns1, ns2;
int result;
n = n_randint(state, 8);
deg = 1 + n_randint(state, 5);
bits = 1 + n_randint(state, 100);
density = n_randint(state, 100) * 0.01;
fmpz_poly_mat_init(A, n, n);
fmpz_poly_mat_init(Ainv, n, n);
fmpz_poly_init(den1);
fmpz_poly_init(den2);
fmpz_poly_mat_randtest_sparse(A, state, deg, bits, density);
ns1 = fmpz_poly_mat_inv(Ainv, den1, A);
ns2 = fmpz_poly_mat_inv(A, den2, A);
result = ns1 == ns2;
if (result && ns1 != 0)
{
result = fmpz_poly_equal(den1, den2) &&
fmpz_poly_mat_equal(A, Ainv);
}
if (!result)
{
printf("FAIL (aliasing)!\n");
fmpz_poly_mat_print(A, "x"); printf("\n");
fmpz_poly_mat_print(Ainv, "x"); printf("\n");
abort();
}
fmpz_poly_mat_clear(A);
fmpz_poly_mat_clear(Ainv);
fmpz_poly_clear(den1);
fmpz_poly_clear(den2);
}
/* Check A^(-1) = A = 1 */
for (i = 0; i < 1000; i++)
{
fmpz_poly_mat_t A, Ainv, B, Iden;
fmpz_poly_t den, det;
long n, bits, deg;
float density;
int nonsingular;
n = n_randint(state, 10);
deg = 1 + n_randint(state, 5);
bits = 1 + n_randint(state, 100);
density = n_randint(state, 100) * 0.01;
fmpz_poly_mat_init(A, n, n);
fmpz_poly_mat_init(Ainv, n, n);
fmpz_poly_mat_init(B, n, n);
fmpz_poly_mat_init(Iden, n, n);
fmpz_poly_init(den);
fmpz_poly_init(det);
fmpz_poly_mat_randtest_sparse(A, state, deg, bits, density);
nonsingular = fmpz_poly_mat_inv(Ainv, den, A);
fmpz_poly_mat_det_interpolate(det, A);
if (n == 0)
{
if (nonsingular == 0 || !fmpz_poly_is_one(den))
{
printf("FAIL: expected empty matrix to pass\n");
abort();
}
}
else
{
if (!fmpz_poly_equal(den, det))
{
fmpz_poly_neg(det, det);
printf("FAIL: den != det(A)\n");
abort();
}
fmpz_poly_mat_mul(B, Ainv, A);
fmpz_poly_mat_one(Iden);
fmpz_poly_mat_scalar_mul_fmpz_poly(Iden, Iden, den);
if (!fmpz_poly_mat_equal(B, Iden))
{
printf("FAIL:\n");
printf("A:\n");
fmpz_poly_mat_print(A, "x");
printf("Ainv:\n");
fmpz_poly_mat_print(Ainv, "x");
printf("B:\n");
fmpz_poly_mat_print(B, "x");
printf("den:\n");
fmpz_poly_print_pretty(den, "x");
abort();
}
}
fmpz_poly_clear(den);
fmpz_poly_clear(det);
fmpz_poly_mat_clear(A);
fmpz_poly_mat_clear(Ainv);
fmpz_poly_mat_clear(B);
fmpz_poly_mat_clear(Iden);
}
flint_randclear(state);
_fmpz_cleanup();
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_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;
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;
}
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(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("inv_series_newton....");
fflush(stdout);
/* Check Q^{-1} * Q is congruent 1 mod t^n */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c, one;
slong n = n_randint(state, 80) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(one);
fmpz_poly_randtest_not_zero(a, state, n_randint(state, 80) + 1, 100);
fmpz_poly_set_coeff_si(a, 0, n_randint(state, 2) ? 1 : -1);
fmpz_poly_set_ui(one, 1);
fmpz_poly_inv_series_newton(b, a, n);
fmpz_poly_mullow(c, a, b, n);
result = (fmpz_poly_equal(c, one));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(one);
}
/* Verify bug fix for the case Q = -1 mod (x) */
{
fmpz_poly_t a, b, c, one;
slong n = 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(one);
fmpz_poly_set_si(a, -1);
fmpz_poly_set_ui(one, 1);
fmpz_poly_inv_series_newton(b, a, n);
fmpz_poly_mullow(c, a, b, n);
result = (fmpz_poly_equal(c, one));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(one);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sqrlow_KS....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b;
slong len, trunc;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
len = 2 * b->length - 1;
trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length);
fmpz_poly_sqrlow_KS(a, b, trunc);
fmpz_poly_sqrlow_KS(b, b, trunc);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
/* Compare with sqr_KS */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
slong len, trunc;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 200);
len = 2 * b->length - 1;
trunc = (len <= 0) ? 0 : n_randint(state, 2 * b->length - 1);
fmpz_poly_sqr_KS(a, b);
fmpz_poly_truncate(a, trunc);
fmpz_poly_sqrlow_KS(c, b, trunc);
result = (fmpz_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("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()
{
slong iter;
flint_rand_t state;
flint_printf("get_unique_fmpz_poly....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong prec, c;
fmpz_poly_t A, B, C;
acb_poly_t a, b;
fmpz_poly_init(A);
fmpz_poly_init(B);
fmpz_poly_init(C);
acb_poly_init(a);
acb_poly_init(b);
fmpz_poly_randtest(A, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
fmpz_poly_randtest(B, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
fmpz_poly_randtest(C, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
c = 1 + n_randint(state, 1000);
prec = 2 + n_randint(state, 100);
for ( ; ; )
{
acb_poly_set_fmpz_poly(a, A, prec);
acb_poly_set2_fmpz_poly(b, B, C, prec);
acb_poly_scalar_mul_2exp_si(b, b, -c);
acb_poly_add(a, a, b, prec);
acb_poly_sub(a, a, b, prec);
if (acb_poly_get_unique_fmpz_poly(B, a))
{
if (!fmpz_poly_equal(A, B))
{
flint_printf("FAIL\n\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("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
abort();
}
break;
}
else
{
prec *= 2;
}
}
fmpz_poly_clear(A);
fmpz_poly_clear(B);
fmpz_poly_clear(C);
acb_poly_clear(a);
acb_poly_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
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_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("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)
{
long i;
flint_rand_t state;
printf("trace....");
fflush(stdout);
flint_randinit(state);
/* Test trace(AB) = trace(BA) */
for (i = 0; i < 1000; i++)
{
fmpz_poly_mat_t A, B, AB, BA;
fmpz_poly_t trab, trba;
long m, n;
m = n_randint(state, 10);
n = n_randint(state, 10);
fmpz_poly_mat_init(A, m, n);
fmpz_poly_mat_init(B, n, m);
fmpz_poly_mat_init(AB, m, m);
fmpz_poly_mat_init(BA, n, n);
fmpz_poly_init(trab);
fmpz_poly_init(trba);
fmpz_poly_mat_randtest(A, state, 1 + n_randint(state, 10),
1 + n_randint(state, 100));
fmpz_poly_mat_randtest(B, state, 1 + n_randint(state, 10),
1 + n_randint(state, 100));
fmpz_poly_mat_mul(AB, A, B);
fmpz_poly_mat_mul(BA, B, A);
fmpz_poly_mat_trace(trab, AB);
fmpz_poly_mat_trace(trba, BA);
if (!fmpz_poly_equal(trab, trba))
{
printf("FAIL:\n");
fmpz_poly_mat_print(A, "x"), printf("\n");
fmpz_poly_mat_print(B, "x"), printf("\n");
fmpz_poly_mat_print(AB, "x"), printf("\n");
fmpz_poly_mat_print(BA, "x"), printf("\n");
printf("tr(AB): "), fmpz_poly_print(trab), printf("\n");
printf("tr(BA): "), fmpz_poly_print(trba), printf("\n");
abort();
}
fmpz_poly_mat_clear(A);
fmpz_poly_mat_clear(B);
fmpz_poly_mat_clear(AB);
fmpz_poly_mat_clear(BA);
fmpz_poly_clear(trab);
fmpz_poly_clear(trba);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}