int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("dot_ptr....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
long len;
nmod_t mod;
mp_limb_t m, res, res2;
mp_ptr x, y;
mp_ptr * z;
int limbs1;
long j, offset;
len = n_randint(state, 1000) + 1;
m = n_randtest_not_zero(state);
offset = n_randint(state, 10);
nmod_init(&mod, m);
x = _nmod_vec_init(len);
y = _nmod_vec_init(len);
z = flint_malloc(sizeof(mp_ptr) * len);
_nmod_vec_randtest(x, state, len, mod);
_nmod_vec_randtest(y, state, len, mod);
for (j = 0; j < len; j++)
z[j] = &y[j] + offset;
limbs1 = _nmod_vec_dot_bound_limbs(len, mod);
res = _nmod_vec_dot_ptr(x, z, -offset, len, mod, limbs1);
res2 = _nmod_vec_dot(x, y, len, mod, limbs1);
if (res != res2)
{
printf("FAIL:\n");
printf("m = %lu\n", m);
printf("len = %ld\n", len);
printf("limbs1 = %d\n", limbs1);
abort();
}
_nmod_vec_clear(x);
_nmod_vec_clear(y);
flint_free(z);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
mp_limb_t n;
int j;
FLINT_TEST_INIT(state);
flint_printf("factorial_mod2_preinv....");
fflush(stdout);
for (n = 0; n < 100 * flint_test_multiplier(); n++)
{
mp_limb_t p, pinv, x, y;
for (j = 0; j < 10; j++)
{
p = n_randtest_not_zero(state);
pinv = n_preinvert_limb(p);
x = n_factorial_mod2_preinv(n, p, pinv);
y = n_factorial_mod2_foolproof(n, p, pinv);
if (x != y)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu\np = %wu\nx = %wu\ny = %wu\n", n, p, x, y);
abort();
}
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("bit_pack/bit_unpack....");
fflush(stdout);
/* Check aliasing of a and c */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n;
ulong bits;
mp_ptr mpn;
do
{
n = n_randtest_not_zero(state);
} while (n == 1);
bits = 2 * FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
do
{
nmod_poly_randtest(a, state, n_randint(state, 100));
} while (a->length == 0);
mpn =
malloc(sizeof(mp_limb_t) *
((bits * a->length - 1) / FLINT_BITS + 1));
_nmod_poly_bit_pack(mpn, a->coeffs, a->length, bits);
nmod_poly_fit_length(b, a->length);
_nmod_poly_bit_unpack(b->coeffs, a->length, mpn, bits, a->mod);
b->length = a->length;
result = (nmod_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("root_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
ulong k;
slong prec;
prec = 2 + n_randint(state, 2000);
k = n_randtest_not_zero(state);
arb_init(a);
arb_init(b);
arb_init(c);
arb_randtest(a, state, 1 + n_randint(state, 2000), 1 + n_randint(state, 100));
arb_randtest(b, state, 1 + n_randint(state, 2000), 1 + n_randint(state, 100));
arb_root_ui(b, a, k, prec);
arb_pow_ui(c, b, k, prec);
if (!arb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("k = %wu\n", k);
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
arb_root_ui(a, a, k, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
FLINT_TEST_INIT(state);
flint_printf("set_si....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
fmpz_t p, q;
slong P, Q;
fmpq_init(x);
fmpq_init(y);
fmpz_init(p);
fmpz_init(q);
P = z_randtest(state);
Q = n_randtest_not_zero(state);
fmpz_set_si(p, P);
fmpz_set_ui(q, Q);
fmpq_set_fmpz_frac(x, p, q);
fmpq_set_si(y, P, Q);
if (!fmpq_is_canonical(y) || !fmpq_equal(x, y))
{
flint_printf("FAIL");
flint_printf("p: "); fmpz_print(p); flint_printf("\n");
flint_printf("q: "); fmpz_print(q); flint_printf("\n");
flint_printf("x: "); fmpq_print(x); flint_printf("\n");
flint_printf("y: "); fmpq_print(y); flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(p);
fmpz_clear(q);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("dot_bound_limbs....");
fflush(stdout);
for (i = 0; i < 1000000; i++)
{
slong len;
nmod_t mod;
mp_limb_t m;
int limbs1, limbs2;
mpz_t t;
len = n_randint(state, 10000) + 1;
m = n_randtest_not_zero(state);
nmod_init(&mod, m);
limbs1 = _nmod_vec_dot_bound_limbs(len, mod);
mpz_init2(t, 4*FLINT_BITS);
flint_mpz_set_ui(t, m-1);
mpz_mul(t, t, t);
flint_mpz_mul_ui(t, t, len);
limbs2 = mpz_size(t);
if (limbs1 != limbs2)
{
flint_printf("FAIL:\n");
flint_printf("m = %wu\n", m);
flint_printf("len = %wd\n", len);
flint_printf("limbs1 = %d\n", limbs1);
flint_printf("limbs2 = %d\n", limbs2);
gmp_printf("bound: %Zd\n", t);
abort();
}
mpz_clear(t);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("reduce....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
long j, len = n_randint(state, 100) + 1;
mp_ptr vec = _nmod_vec_init(len);
mp_ptr vec2 = _nmod_vec_init(len);
mp_limb_t n = n_randtest_not_zero(state);
nmod_t mod;
nmod_init(&mod, n);
for (j = 0; j < len; j++)
{
vec[j] = n_randtest(state);
vec2[j] = vec[j];
}
_nmod_vec_reduce(vec, vec, len, mod);
for (j = 0; j < len; j++)
vec2[j] = n_mod2_preinv(vec2[j], mod.n, mod.ninv);
result = _nmod_vec_equal(vec, vec2, len);
if (!_nmod_vec_equal(vec, vec2, len))
{
printf("FAIL:\n");
printf("len = %ld, n = %ld\n", len, n);
abort();
}
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mullow....");
fflush(stdout);
/* Compare with truncated product of a and b */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
slong trunc;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
trunc = n_randint(state, 50);
nmod_poly_randtest(b, state, trunc);
nmod_poly_randtest(c, state, trunc);
nmod_poly_mullow(a, b, c, trunc);
nmod_poly_mul(b, b, c);
nmod_poly_truncate(b, trunc);
result = (nmod_poly_equal(a, b));
if (!result)
{
flint_printf(":\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
int i, j, result;
flint_rand_t state;
flint_randinit(state);
printf("factor_trial_partial....");
fflush(stdout);
for (i = 0; i < 10000; i++) /* Test random numbers */
{
mp_limb_t n1, n2, prod, limit;
n_factor_t factors;
n_factor_init(&factors);
n1 = n_randtest_not_zero(state);
limit = n_sqrt(n1);
n2 = n_factor_trial_partial(&factors, n1, &prod, 10000UL, limit);
if (n1 != n2*prod)
{
printf("FAIL:\n");
printf("n1 = %lu, n2 = %lu, prod = %lu\n", n1, n2, prod);
abort();
}
for (j = 0; j < factors.num; j++)
{
n2 *= n_pow(factors.p[j], factors.exp[j]);
}
result = (n1 == n2);
if (!result)
{
printf("FAIL:\n");
printf("n1 = %lu, n2 = %lu\n", n1, n2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
ulong j;
FLINT_TEST_INIT(state);
flint_printf("get/set_coeff_ui....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t c1 = n_randtest(state), c2;
j = n_randint(state, 100);
nmod_poly_init(a, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(a, j, c1);
c2 = nmod_poly_get_coeff_ui(a, j);
result = (c2 == c1 % n);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("j = %wu, c1 = %wu, c2 = %wu, n = %wu\n", j, c1, c2, a->mod.n);
nmod_poly_print(a), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("neg....");
fflush(stdout);
/* Check neg neg a == a */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_neg(b, a);
nmod_poly_neg(b, b);
result = (nmod_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("lll_mod_preinv....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000000; i++)
{
mp_limb_t d, dinv, nh, nm, nl, r1, r2, m;
d = n_randtest_not_zero(state);
m = n_randtest(state);
nh = n_randint(state, d);
nm = n_randtest(state);
nl = n_randtest(state);
dinv = n_preinvert_limb(d);
r2 = n_lll_mod_preinv(nh, nm, nl, d, dinv);
nm = n_ll_mod_preinv(nh, nm, d, dinv);
r1 = n_ll_mod_preinv(nm, nl, d, dinv);
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("nh = %lu, nm = %ld, nl = %lu, d = %lu, dinv = %lu\n", nh, nm, nl, d, dinv);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("sdiv_qrnnd....");
fflush(stdout);
for (i = 0; i < 1000000; i++)
{
mp_limb_signed_t d, nh, nl, q, r, ph, pl;
do
{
d = n_randtest_not_zero(state);
nh = n_randtest(state);
} while (FLINT_ABS(nh) >= FLINT_ABS(d)/2);
nl = n_randtest(state);
sdiv_qrnnd(q, r, nh, nl, d);
smul_ppmm(ph, pl, d, q);
if (r < 0L) sub_ddmmss(ph, pl, ph, pl, 0UL, -r);
else add_ssaaaa(ph, pl, ph, pl, 0UL, r);
result = ((ph == nh) && (pl == nl));
if (!result)
{
printf("FAIL:\n");
printf("nh = %lu, nl = %lu, d = %lu\n", nh, nl, d);
printf("ph = %lu, pl = %lu\n", ph, pl);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void sample(void * arg, ulong count)
{
mp_limb_t d, q, r, dinv, norm;
mp_ptr array = (mp_ptr) flint_malloc(200 * sizeof(mp_limb_t));
FLINT_TEST_INIT(state);
ulong i;
int j;
d = n_randtest_not_zero(state);
count_leading_zeros(norm, d);
d <<= norm;
for (i = 0; i < count; i++)
{
for (j = 0; j < 200; j+=2)
{
do
{
array[j] = n_randtest(state);
} while (array[j] >= d);
array[j + 1] = n_randtest(state);
}
invert_limb(dinv, d);
prof_start();
for (j = 0; j < 200; j+=2)
{
udiv_qrnnd_preinv(q, r, array[j], array[j+1], d, dinv);
}
prof_stop();
if (q + r == 0) flint_printf("\r");
}
flint_randclear(state);
flint_free(array);
}
void sample(void * arg, ulong count)
{
mp_limb_t d;
mp_ptr array = (mp_ptr) flint_malloc(200 * sizeof(mp_limb_t));
flint_rand_t state;
ulong i;
int j;
flint_randinit(state);
d = n_randtest_not_zero(state);
for (i = 0; i < count; i++)
{
for (j = 0; j < 200; j+=2)
{
do
{
array[j] = n_randtest(state);
} while (array[j] >= d);
array[j + 1] = n_randtest(state);
}
prof_start();
for (j = 0; j < 200; j+=2)
{
udiv_qrnnd(array[j], array[j+1], array[j], array[j+1], d);
}
prof_stop();
for (j = 0; j < 200; j++)
if (array[j] == 0) printf("\r");
}
flint_randclear(state);
flint_free(array);
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mod2_preinv....");
fflush(stdout);
for (i = 0; i < 100000 * flint_test_multiplier(); i++)
{
mp_limb_t d, dinv, n, r1, r2;
d = n_randtest_not_zero(state);
n = n_randtest(state);
dinv = n_preinvert_limb(d);
r1 = n_mod2_preinv(n, d, dinv);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu, d = %wu, dinv = %wu\n", n, d, dinv);
flint_printf("r1 = %wu, r2 = %wu\n", r1, r2);
abort();
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("xgcd_hgcd....");
fflush(stdout);
/*
Compare with result from gcd and check a*s + b*t = g
*/
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, c, g1, g2, s, t, sum, temp;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_init(g1, n);
nmod_poly_init(g2, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_init(sum, n);
nmod_poly_init(temp, n);
nmod_poly_randtest(a, state, n_randint(state, 600));
nmod_poly_randtest(b, state, n_randint(state, 600));
nmod_poly_randtest(c, state, n_randint(state, 400));
nmod_poly_mul(a, a, c);
nmod_poly_mul(b, b, c);
nmod_poly_gcd(g1, a, b);
nmod_poly_xgcd_hgcd(g2, s, t, a, b);
nmod_poly_mul(sum, s, a);
nmod_poly_mul(temp, t, b);
nmod_poly_add(sum, sum, temp);
result = (nmod_poly_equal(g1, g2) && nmod_poly_equal(g1, sum)
&& (g1->length == 0 || g1->coeffs[g1->length - 1] == 1));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(c), printf("\n\n");
nmod_poly_print(g1), printf("\n\n");
nmod_poly_print(g2), printf("\n\n");
nmod_poly_print(sum), printf("\n\n");
nmod_poly_print(s), printf("\n\n");
nmod_poly_print(t), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
nmod_poly_clear(g1);
nmod_poly_clear(g2);
nmod_poly_clear(s);
nmod_poly_clear(t);
nmod_poly_clear(sum);
nmod_poly_clear(temp);
}
/* Check aliasing of a and g */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(a, s, t, a, b);
result = (nmod_poly_equal(a, g));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of b and g */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(b, s, t, a, b);
result = (nmod_poly_equal(b, g));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of s and a */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(g, a, t, a, b);
result = (nmod_poly_equal(s, a));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(s), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of s and b */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(g, b, t, a, b);
result = (nmod_poly_equal(s, b));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(s), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of t and a */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(g, s, a, a, b);
result = (nmod_poly_equal(t, a));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(t), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of t and b */
for (i = 0; i < 200; i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_xgcd_hgcd(g, s, t, a, b);
nmod_poly_xgcd_hgcd(g, s, b, a, b);
result = (nmod_poly_equal(t, b));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(t), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("gcd_euclidean....");
fflush(stdout);
/*
Find coprime polys, multiply by another poly
and check the GCD is that poly
*/
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, c, g;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_init(g, n);
do {
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_gcd_euclidean(g, a, b);
} while (g->length != 1);
do {
nmod_poly_randtest(c, state, n_randint(state, 200));
} while (c->length < 2);
nmod_poly_make_monic(c, c);
nmod_poly_mul(a, a, c);
nmod_poly_mul(b, b, c);
nmod_poly_gcd_euclidean(g, a, b);
result = (nmod_poly_equal(g, c));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(c), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
nmod_poly_clear(g);
}
/* Check aliasing of a and g */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, g;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_gcd_euclidean(g, a, b);
nmod_poly_gcd_euclidean(a, a, b);
result = (nmod_poly_equal(a, g));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
}
/* Check aliasing of b and g */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, g;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_randtest(a, state, n_randint(state, 200));
nmod_poly_randtest(b, state, n_randint(state, 200));
nmod_poly_gcd_euclidean(g, a, b);
nmod_poly_gcd_euclidean(b, a, b);
result = (nmod_poly_equal(b, g));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_divexact_ui....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b;
ulong n = n_randtest_not_zero(state);
slong len = n_randint(state, 100);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_scalar_mul_ui(a, a, len, n);
_fmpz_vec_scalar_divexact_ui(b, a, len, n);
_fmpz_vec_scalar_divexact_ui(a, a, len, n);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
flint_printf("FAIL:\n");
_fmpz_vec_print(a, len), flint_printf("\n\n");
_fmpz_vec_print(b, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
/* Check that a * n / n == a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b;
ulong n = n_randtest_not_zero(state);
slong len = n_randint(state, 100);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_set(b, a, len);
_fmpz_vec_scalar_mul_ui(a, a, len, n);
_fmpz_vec_scalar_divexact_ui(a, a, len, n);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
flint_printf("FAIL:\n");
_fmpz_vec_print(a, len), flint_printf("\n\n");
_fmpz_vec_print(b, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("bit_pack/bit_unpack....");
fflush(stdout);
/* Check aliasing of a and c */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n;
ulong bits;
mp_ptr mpn;
do
{
n = n_randtest_not_zero(state);
} while (n == 1);
bits = 2 * FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
do
{
nmod_poly_randtest(a, state, n_randint(state, 100));
} while (a->length == 0);
mpn =
flint_malloc(sizeof(mp_limb_t) *
((bits * a->length - 1) / FLINT_BITS + 1));
_nmod_poly_bit_pack(mpn, a->coeffs, a->length, bits);
nmod_poly_fit_length(b, a->length);
_nmod_poly_bit_unpack(b->coeffs, a->length, mpn, bits, a->mod);
b->length = a->length;
result = (nmod_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
flint_free(mpn);
}
for (i = 0; i < 20000; i++)
{
fmpz_t f;
nmod_poly_t A, B;
long b;
mp_limb_t n;
do
{
n = n_randtest_not_zero(state);
} while (n == 1);
fmpz_init(f);
nmod_poly_init(A, n);
nmod_poly_init(B, n);
nmod_poly_randtest(A, state, 1+n_randint(state,100));
b = FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS);
nmod_poly_bit_pack(f, A, b);
nmod_poly_bit_unpack(B, f, b);
if (!nmod_poly_equal(A, B))
{
mpz_t zz;
printf("FAIL:\n");
printf("INPUT: ");
nmod_poly_print(A);
printf("\n");
mpz_init(zz); fmpz_get_mpz(zz, f);
printf("PACKED: ");
mpz_out_str(stdout, 2, zz);
printf("\n");
printf("OUTPUT: ");
nmod_poly_print(B);
printf("\n\n");
abort();
}
fmpz_clear(f);
nmod_poly_clear(A);
nmod_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("inv_series_newton....");
fflush(stdout);
/* Check Q * Qinv = 1 mod x^n */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, qinv, prod;
slong m;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(prod, n);
nmod_poly_init(qinv, n);
nmod_poly_init(q, n);
do nmod_poly_randtest(q, state, n_randint(state, 2000));
while (q->length == 0 || q->coeffs[0] == 0);
m = n_randint(state, q->length) + 1;
nmod_poly_inv_series_newton(qinv, q, m);
nmod_poly_mul(prod, q, qinv);
nmod_poly_truncate(prod, m);
result = (prod->length == 1 && prod->coeffs[0] == 1);
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(qinv), flint_printf("\n\n");
nmod_poly_print(prod), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(qinv);
nmod_poly_clear(prod);
}
/* Check aliasing of q and qinv */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, qinv;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(qinv, n);
do nmod_poly_randtest(q, state, n_randint(state, 1000));
while (q->length == 0 || q->coeffs[0] == 0);
m = n_randint(state, q->length) + 1;
nmod_poly_inv_series_newton(qinv, q, m);
nmod_poly_inv_series_newton(q, q, m);
result = (nmod_poly_equal(q, qinv));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(qinv), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(qinv);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
slong m, n, mod, mod2, rep;
FLINT_TEST_INIT(state);
flint_printf("transpose....");
fflush(stdout);
/* Rectangular transpose, same modulus */
for (rep = 0; rep < 100 * flint_test_multiplier(); rep++)
{
nmod_mat_t A, B, C;
m = n_randint(state, 20);
n = n_randint(state, 20);
mod = n_randtest_not_zero(state);
nmod_mat_init(A, m, n, mod);
nmod_mat_init(B, n, m, mod);
nmod_mat_init(C, m, n, mod);
nmod_mat_randtest(A, state);
nmod_mat_randtest(B, state);
nmod_mat_transpose(B, A);
nmod_mat_transpose(C, B);
if (!nmod_mat_equal(C, A))
{
flint_printf("FAIL: C != A\n");
abort();
}
nmod_mat_clear(A);
nmod_mat_clear(B);
nmod_mat_clear(C);
}
/* Rectangular transpose, different modulus */
for (rep = 0; rep < 100 * flint_test_multiplier(); rep++)
{
nmod_mat_t A, AT, B, BT, AT2;
m = n_randint(state, 20);
n = n_randint(state, 20);
mod = n_randtest_not_zero(state);
mod2 = n_randtest_not_zero(state);
nmod_mat_init(A, m, n, mod);
nmod_mat_init(AT, n, m, mod);
nmod_mat_init(B, m, n, mod2);
nmod_mat_init(BT, n, m, mod2);
nmod_mat_init(AT2, n, m, mod2);
nmod_mat_randtest(A, state);
nmod_mat_set(B, A);
nmod_mat_transpose(AT, A);
nmod_mat_transpose(BT, B);
nmod_mat_set(AT2, AT);
if (!nmod_mat_equal(BT, AT2))
{
flint_printf("FAIL: AT != BT\n");
abort();
}
nmod_mat_clear(A);
nmod_mat_clear(AT);
nmod_mat_clear(AT2);
nmod_mat_clear(B);
nmod_mat_clear(BT);
}
/* Self-transpose */
for (rep = 0; rep < 100 * flint_test_multiplier(); rep++)
{
nmod_mat_t A, B;
m = n_randint(state, 20);
mod = n_randtest_not_zero(state);
nmod_mat_init(A, m, m, mod);
nmod_mat_init(B, m, m, mod);
nmod_mat_randtest(A, state);
nmod_mat_set(B, A);
nmod_mat_transpose(B, B);
nmod_mat_transpose(B, B);
if (!nmod_mat_equal(B, A))
{
flint_printf("FAIL: B != A\n");
abort();
}
nmod_mat_clear(A);
nmod_mat_clear(B);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("add....");
fflush(stdout);
/* Check aliasing of a and c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_randtest(b, state, n_randint(state, 100));
nmod_poly_add(c, a, b);
nmod_poly_add(a, a, b);
result = (nmod_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(c), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_randtest(b, state, n_randint(state, 100));
nmod_poly_add(c, a, b);
nmod_poly_add(b, a, b);
result = (nmod_poly_equal(b, c));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(c), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("shift_left_right....");
fflush(stdout);
/* Check a << shift >> shift == a */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
long shift = n_randint(state, 100);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_shift_left(b, a, shift);
nmod_poly_shift_right(b, b, shift);
result = (nmod_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("shift = %ld, a->length = %ld, n = %lu\n",
shift, a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
/* Check a << shift >> shift == a aliasing the other way */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
long shift = n_randint(state, 100);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(c, state, n_randint(state, 100));
nmod_poly_set(a, c);
nmod_poly_shift_left(c, c, shift);
nmod_poly_shift_right(b, c, shift);
result = (nmod_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
printf("shift = %ld, c->length = %ld, n = %lu\n",
shift, c->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("xgcd_euclidean....");
fflush(stdout);
/*
Compare with result from gcd and check a*s + b*t = g
*/
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c, g1, s, t, g2;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_init(g1, n);
nmod_poly_init(g2, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_randtest(c, state, n_randtest(state) % 200);
nmod_poly_mul(a, a, c);
nmod_poly_mul(b, b, c);
nmod_poly_gcd_euclidean(g1, a, b);
nmod_poly_xgcd_euclidean(g2, s, t, a, b);
nmod_poly_mul(s, s, a);
nmod_poly_mul(t, t, b);
nmod_poly_add(s, s, t);
result = (nmod_poly_equal(g1, g2) && nmod_poly_equal(s, g1)
&& (g1->length == 0 || g1->coeffs[g1->length - 1] == 1));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(c), flint_printf("\n\n");
nmod_poly_print(g1), flint_printf("\n\n");
nmod_poly_print(g2), flint_printf("\n\n");
nmod_poly_print(s), flint_printf("\n\n");
nmod_poly_print(t), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
nmod_poly_clear(g1);
nmod_poly_clear(g2);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of a and g */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(a, s, t, a, b);
result = (nmod_poly_equal(a, g));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(g), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of b and g */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(b, s, t, a, b);
result = (nmod_poly_equal(b, g));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(g), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of s and a */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(g, a, t, a, b);
result = (nmod_poly_equal(s, a));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(s), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of s and b */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(g, b, t, a, b);
result = (nmod_poly_equal(s, b));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(s), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of t and a */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(g, s, a, a, b);
result = (nmod_poly_equal(t, a));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(t), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
/* Check aliasing of t and b */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, g, s, t;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(g, n);
nmod_poly_init(s, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randtest(state) % 200);
nmod_poly_randtest(b, state, n_randtest(state) % 200);
nmod_poly_xgcd_euclidean(g, s, t, a, b);
nmod_poly_xgcd_euclidean(g, s, b, a, b);
result = (nmod_poly_equal(t, b));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(t), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(g);
nmod_poly_clear(s);
nmod_poly_clear(t);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result = 1;
flint_rand_t state;
flint_randinit(state);
printf("compose_divconquer....");
fflush(stdout);
/* Compare aliasing */
for (i = 0; i < 5000; i++)
{
nmod_poly_t a, b, r1;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(r1, n);
nmod_poly_randtest(a, state, n_randint(state, 30));
nmod_poly_randtest(b, state, n_randint(state, 15));
nmod_poly_compose_divconquer(r1, a, b);
nmod_poly_compose_divconquer(a, a, b);
result = nmod_poly_equal(r1, a);
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(r1), printf("\n\n");
nmod_poly_print(a), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(r1);
}
/* Compare other aliasing */
for (i = 0; i < 5000; i++)
{
nmod_poly_t a, b, r1;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(r1, n);
nmod_poly_randtest(a, state, n_randint(state, 30));
nmod_poly_randtest(b, state, n_randint(state, 15));
nmod_poly_compose_divconquer(r1, a, b);
nmod_poly_compose_divconquer(b, a, b);
result = nmod_poly_equal(r1, b);
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(r1), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(r1);
}
/* Compare with compose_horner */
for (i = 0; i < 5000; i++)
{
nmod_poly_t a, b, r1, r2;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(r1, n);
nmod_poly_init(r2, n);
nmod_poly_randtest(a, state, n_randint(state, 30));
nmod_poly_randtest(b, state, n_randint(state, 15));
nmod_poly_compose_divconquer(r1, a, b);
nmod_poly_compose_horner(r2, a, b);
result = nmod_poly_equal(r1, r2);
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(r1), printf("\n\n");
nmod_poly_print(r2), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(r1);
nmod_poly_clear(r2);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("div_series....");
fflush(stdout);
/* Check A/B * B = A */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b, prod;
slong m;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(prod, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(q, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 2000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_mullow(prod, q, b, m);
nmod_poly_truncate(a, m);
result = (nmod_poly_equal(a, prod));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(prod), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(prod);
}
/* Check aliasing of q and a */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 1000));
do nmod_poly_randtest(b, state, n_randint(state, 1000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 1000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_div_series(a, a, b, m);
result = (nmod_poly_equal(q, a));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(a), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
}
/* Check aliasing of q and b */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 1000));
do nmod_poly_randtest(b, state, n_randint(state, 1000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 1000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_div_series(b, a, b, m);
result = (nmod_poly_equal(q, b));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mul_KS....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(b, state, n_randint(state, 50));
nmod_poly_randtest(c, state, n_randint(state, 50));
nmod_poly_mul_KS(a, b, c, 0);
nmod_poly_mul_KS(b, b, c, 0);
result = (nmod_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(b, state, n_randint(state, 50));
nmod_poly_randtest(c, state, n_randint(state, 50));
nmod_poly_mul_KS(a, b, c, 0);
nmod_poly_mul_KS(c, b, c, 0);
result = (nmod_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(c), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
/* Compare with mul_classical */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
nmod_poly_t a1, a2, b, c;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a1, n);
nmod_poly_init(a2, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
nmod_poly_randtest(b, state, n_randint(state, 50));
nmod_poly_randtest(c, state, n_randint(state, 50));
nmod_poly_mul_classical(a1, b, c);
nmod_poly_mul_KS(a2, b, c, 0);
result = (nmod_poly_equal(a1, a2));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a1), flint_printf("\n\n");
nmod_poly_print(a2), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a1);
nmod_poly_clear(a2);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("divexact_ui....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
fmpz_t a, c;
mpz_t e, f, g;
ulong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = n_randtest_not_zero(state);
fmpz_mul_ui(c, a, n);
fmpz_get_mpz(e, c);
fmpz_divexact_ui(a, c, n);
mpz_divexact_ui(f, e, n);
fmpz_get_mpz(g, a);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
printf("FAIL1\n");
gmp_printf("n = %lu, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of a and c */
for (i = 0; i < 100000; i++)
{
fmpz_t a, c;
mpz_t d, f, g;
ulong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(d);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = n_randtest_not_zero(state);
fmpz_mul_ui(c, a, n);
fmpz_get_mpz(d, c);
fmpz_divexact_ui(c, c, n);
mpz_divexact_ui(f, d, n);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
printf("FAIL:\n");
gmp_printf("d = %Zd, n = %lu, f = %Zd, g = %Zd\n", d, n, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(f);
mpz_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}