void fill_array(ulong * ret, mp_bitcnt_t bits, flint_rand_t state)
{
ulong n;
n_factor_t factors;
ulong i, primes = (1<<(bits/3))/10 + 1;
for (i = 0; i < 1024; i++)
{
do
{
n_factor_init(&factors);
n = n_randbits(state, bits);
} while (n_is_probabprime(n) || (n_factor_trial(&factors, n, primes) != n));
ret[i] = n;
}
}
mp_limb_t n_nextprime(mp_limb_t n, int proved)
{
mp_limb_t * moduli;
ulong i, index;
if (n < 7)
{
if (n < 2)
return 2;
n++;
n |= 1;
return n;
}
if (n >= UWORD_MAX_PRIME)
{
flint_printf("Exception (n_nextprime). No larger single-limb prime exists.\n");
abort();
}
index = n % 30;
n += nextmod30[index];
index = nextindex[index];
if (n <= flint_primes_small[NEXTPRIME_PRIMES-1])
{
if (n == 7) return 7;
if (n == 11) return 11;
if (n == 13) return 13;
while (((n % 7) == 0) || ((n % 11) == 0) || ((n % 13) == 0))
{
n += nextmod30[index];
index = nextindex[index];
}
return n;
}
moduli = (mp_limb_t *) flint_malloc(NEXTPRIME_PRIMES * sizeof(mp_limb_t));
for (i = 3; i < NEXTPRIME_PRIMES; i++)
moduli[i] = (n % flint_primes_small[i]);
while (1)
{
ulong composite = 0;
ulong diff, acc, pr;
diff = nextmod30[index];
/* First check residues */
for (i = 3; i < NEXTPRIME_PRIMES; i++)
{
composite |= (moduli[i] == 0);
acc = moduli[i] + diff;
pr = flint_primes_small[i];
moduli[i] = acc >= pr ? acc - pr : acc;
}
if (composite)
{
n += diff;
index = nextindex[index];
continue;
}
if ((!proved && n_is_probabprime(n)) || (proved && n_is_prime(n)))
{
break;
}
else
{
n += diff;
index = nextindex[index];
}
}
flint_free(moduli);
return n;
}
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;
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("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)
{
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_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_rand_t state;
flint_randinit(state);
printf("div_newton....");
fflush(stdout);
/* Check result of div against divrem */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, q, q2, r;
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(q, n);
nmod_poly_init(q2, n);
nmod_poly_init(r, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0);
nmod_poly_divrem_divconquer(q, r, a, b);
nmod_poly_div_newton(q2, a, b);
result = (nmod_poly_equal(q, q2));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(q), printf("\n\n");
nmod_poly_print(q2), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(q);
nmod_poly_clear(r);
nmod_poly_clear(q2);
}
/* Check aliasing of a and q */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, q;
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(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);
nmod_poly_div_newton(q, a, b);
nmod_poly_div_newton(a, a, b);
result = (nmod_poly_equal(a, q));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(q), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(q);
}
/* Check aliasing of b and q */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, q;
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(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);
nmod_poly_div_newton(q, a, b);
nmod_poly_div_newton(b, a, b);
result = (nmod_poly_equal(b, q));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(q), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(q);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("rem....");
fflush(stdout);
/* Check result of rem */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, q, r, prod;
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(q, n);
nmod_poly_init(r, n);
nmod_poly_init(prod, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0);
nmod_poly_div(q, a, b);
nmod_poly_rem(r, a, b);
nmod_poly_mul(prod, q, b);
nmod_poly_add(prod, prod, r);
result = (nmod_poly_equal(a, prod));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(prod), printf("\n\n");
nmod_poly_print(q), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(q);
nmod_poly_clear(r);
nmod_poly_clear(prod);
}
/* Check aliasing of a and r */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, r;
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(r, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0);
nmod_poly_rem(r, a, b);
nmod_poly_rem(a, a, b);
result = (nmod_poly_equal(a, r));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(r);
}
/* Check aliasing of b and r */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, r;
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(r, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0);
nmod_poly_rem(r, a, b);
nmod_poly_rem(b, a, b);
result = (nmod_poly_equal(b, r));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(r);
}
/* Check result of rem_q1 */
for (i = 0; i < 5000; i++)
{
nmod_poly_t a, b, q0, r0, r;
mp_limb_t n = n_randprime(state, n_randint(state,FLINT_BITS-1)+2, 0);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(q0, n);
nmod_poly_init(r0, n);
nmod_poly_init(r, n);
do nmod_poly_randtest(a, state, n_randint(state, 1000));
while (a->length < 2);
nmod_poly_fit_length(b, a->length - 1);
mpn_zero(b->coeffs, a->length - 1);
nmod_poly_randtest_not_zero(b, state, n_randint(state, 1000) + 1);
do b->coeffs[a->length - 2] = n_randint(state, n);
while (b->coeffs[a->length - 2] == 0);
b->length = a->length - 1;
nmod_poly_divrem(q0, r0, a, b);
nmod_poly_rem(r, a, b);
result = (nmod_poly_equal(r0, r));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
nmod_poly_print(q0), printf("\n\n");
nmod_poly_print(r0), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(q0);
nmod_poly_clear(r0);
nmod_poly_clear(r);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
