void
nmod_poly_compose_mod_brent_kung(nmod_poly_t res,
const nmod_poly_t poly1, const nmod_poly_t poly2,
const nmod_poly_t poly3)
{
long len1 = poly1->length;
long len2 = poly2->length;
long len3 = poly3->length;
long len = len3 - 1;
mp_ptr ptr2;
if (len3 == 0)
{
printf("exception: division by zero in "
"nmod_poly_compose_mod_brent_kung\n");
abort();
}
if (len1 >= len3)
{
printf("exception: nmod_poly_compose_brent_kung: the degree of the"
" first polynomial must be smaller than that of the modulus\n");
abort();
}
if (len1 == 0 || len3 == 1)
{
nmod_poly_zero(res);
return;
}
if (len1 == 1)
{
nmod_poly_set(res, poly1);
return;
}
if (res == poly3 || res == poly1)
{
nmod_poly_t tmp;
nmod_poly_init_preinv(tmp, res->mod.n, res->mod.ninv);
nmod_poly_compose_mod_brent_kung(tmp, poly1, poly2, poly3);
nmod_poly_swap(tmp, res);
nmod_poly_clear(tmp);
return;
}
ptr2 = _nmod_vec_init(len);
if (len2 <= len)
{
mpn_copyi(ptr2, poly2->coeffs, len2);
mpn_zero(ptr2 + len2, len - len2);
}
else
{
_nmod_poly_rem(ptr2, poly2->coeffs, len2,
poly3->coeffs, len3, res->mod);
}
nmod_poly_fit_length(res, len);
_nmod_poly_compose_mod_brent_kung(res->coeffs,
poly1->coeffs, len1, ptr2, poly3->coeffs, len3, res->mod);
res->length = len;
_nmod_poly_normalise(res);
_nmod_vec_clear(ptr2);
}
int
main(void)
{
int i, result = 1;
FLINT_TEST_INIT(state);
flint_printf("atanh_series....");
fflush(stdout);
/* Check 2*atanh(A) = atanh(2*A/(1+A^2)) */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t A, B, atanhA, atanhB;
slong n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = 1 + n_randtest(state) % 100;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_init(atanhA, mod);
nmod_poly_init(atanhB, mod);
nmod_poly_randtest(A, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(A, 0, UWORD(0));
nmod_poly_mullow(B, A, A, n);
nmod_poly_set_coeff_ui(B, 0, UWORD(1));
nmod_poly_div_series(B, A, B, n);
nmod_poly_add(B, B, B);
nmod_poly_atanh_series(atanhA, A, n);
nmod_poly_atanh_series(atanhB, B, n);
nmod_poly_add(atanhA, atanhA, atanhA);
result = nmod_poly_equal(atanhA, atanhB);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wd, mod = %wu\n", n, mod);
flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n");
flint_printf("B: "); nmod_poly_print(B), flint_printf("\n\n");
flint_printf("2*atanh(A): "); nmod_poly_print(atanhA), flint_printf("\n\n");
flint_printf("atanh(B): "); nmod_poly_print(atanhB), flint_printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(B);
nmod_poly_clear(atanhA);
nmod_poly_clear(atanhB);
}
/* Check aliasing */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t A, B;
slong n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = n_randtest(state) % 50;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 50));
nmod_poly_set_coeff_ui(A, 0, UWORD(0));
nmod_poly_atanh_series(B, A, n);
nmod_poly_atanh_series(A, A, n);
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);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
slong
nmod_poly_mat_rref(nmod_poly_mat_t R, nmod_poly_t den, const nmod_poly_mat_t A)
{
slong i, j, k, m, n, rank;
slong *pivots, *nonpivots;
rank = nmod_poly_mat_fflu(R, den, NULL, A, 0);
m = nmod_poly_mat_nrows(R);
n = nmod_poly_mat_ncols(R);
/* clear bottom */
for (i = rank; i < m; i++)
for (j = 0; j < n; j++)
nmod_poly_zero(nmod_poly_mat_entry(R, i, j));
/* Convert row echelon form to reduced row echelon form */
if (rank > 1)
{
nmod_poly_t tmp, tmp2;
nmod_poly_init(tmp, nmod_poly_mat_modulus(R));
nmod_poly_init(tmp2, nmod_poly_mat_modulus(R));
pivots = flint_malloc(sizeof(slong) * n);
nonpivots = pivots + rank;
/* find pivot positions */
for (i = j = k = 0; i < rank; i++)
{
while (nmod_poly_is_zero(nmod_poly_mat_entry(R, i, j)))
{
nonpivots[k] = j;
k++;
j++;
}
pivots[i] = j;
j++;
}
while (k < n - rank)
{
nonpivots[k] = j;
k++;
j++;
}
for (k = 0; k < n - rank; k++)
{
for (i = rank - 2; i >= 0; i--)
{
nmod_poly_mul(tmp, den, nmod_poly_mat_entry(R, i, nonpivots[k]));
for (j = i + 1; j < rank; j++)
{
nmod_poly_mul(tmp2, nmod_poly_mat_entry(R, i, pivots[j]),
nmod_poly_mat_entry(R, j, nonpivots[k]));
nmod_poly_sub(tmp, tmp, tmp2);
}
nmod_poly_div(nmod_poly_mat_entry(R, i, nonpivots[k]),
tmp, nmod_poly_mat_entry(R, i, pivots[i]));
}
}
/* clear pivot columns */
for (i = 0; i < rank; i++)
{
for (j = 0; j < rank; j++)
{
if (i == j)
nmod_poly_set(nmod_poly_mat_entry(R, j, pivots[i]), den);
else
nmod_poly_zero(nmod_poly_mat_entry(R, j, pivots[i]));
}
}
flint_free(pivots);
nmod_poly_clear(tmp);
nmod_poly_clear(tmp2);
}
return rank;
}
int
main(void)
{
int i, result = 1;
flint_rand_t state;
flint_randinit(state);
printf("asin_series....");
fflush(stdout);
/* Check asin(A) = atan(A/sqrt(1-A^2)) */
for (i = 0; i < 1000; i++)
{
nmod_poly_t A, B, asinA, atanB;
long n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = 1 + n_randtest(state) % 100;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_init(asinA, mod);
nmod_poly_init(atanB, mod);
nmod_poly_randtest(A, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(A, 0, 0UL);
nmod_poly_mullow(B, A, A, n);
nmod_poly_neg(B, B);
nmod_poly_set_coeff_ui(B, 0, 1UL);
nmod_poly_invsqrt_series(B, B, n);
nmod_poly_mullow(B, A, B, n);
nmod_poly_asin_series(asinA, A, n);
nmod_poly_atan_series(atanB, B, n);
result = nmod_poly_equal(asinA, atanB);
if (!result)
{
printf("FAIL:\n");
printf("n = %ld, mod = %lu\n", n, mod);
printf("A: "); nmod_poly_print(A), printf("\n\n");
printf("B: "); nmod_poly_print(B), printf("\n\n");
printf("asin(A): "); nmod_poly_print(asinA), printf("\n\n");
printf("atan(B): "); nmod_poly_print(atanB), printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(B);
nmod_poly_clear(asinA);
nmod_poly_clear(atanB);
}
/* Check aliasing */
for (i = 0; i < 1000; i++)
{
nmod_poly_t A, B;
long n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = n_randtest(state) % 50;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 50));
nmod_poly_set_coeff_ui(A, 0, 0UL);
nmod_poly_asin_series(B, A, n);
nmod_poly_asin_series(A, A, n);
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(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("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;
}
void
nmod_poly_compose_mod(nmod_poly_t res,
const nmod_poly_t poly1, const nmod_poly_t poly2,
const nmod_poly_t poly3)
{
long len1 = poly1->length;
long len2 = poly2->length;
long len3 = poly3->length;
long len = len3 - 1;
mp_ptr ptr2;
if (len3 == 0)
{
printf("exception: division by zero in nmod_poly_compose_mod\n");
abort();
}
if (len1 == 0 || len3 == 1)
{
nmod_poly_zero(res);
return;
}
if (len1 == 1)
{
nmod_poly_set(res, poly1);
return;
}
if (res == poly3 || res == poly1)
{
nmod_poly_t tmp;
nmod_poly_init_preinv(tmp, res->mod.n, res->mod.ninv);
nmod_poly_compose_mod(tmp, poly1, poly2, poly3);
nmod_poly_swap(tmp, res);
nmod_poly_clear(tmp);
return;
}
ptr2 = _nmod_vec_init(len);
if (len2 <= len)
{
mpn_copyi(ptr2, poly2->coeffs, len2);
mpn_zero(ptr2 + len2, len - len2);
}
else
{
_nmod_poly_rem(ptr2, poly2->coeffs, len2,
poly3->coeffs, len3, res->mod);
}
nmod_poly_fit_length(res, len);
_nmod_poly_compose_mod(res->coeffs,
poly1->coeffs, len1, ptr2, poly3->coeffs, len3, res->mod);
res->length = len;
_nmod_poly_normalise(res);
_nmod_vec_clear(ptr2);
}
int
main(void)
{
int i, j, result = 1;
fmpz_t t;
flint_rand_t state;
flint_randinit(state);
printf("derivative....");
fflush(stdout);
fmpz_init(t);
/* Check derivative by hand */
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_derivative(b, a);
if (a->length <= 1)
result = (b->length == 0);
else
{
for (j = 1; j < a->length; j++)
{
fmpz_set_ui(t, nmod_poly_get_coeff_ui(a, j));
fmpz_mul_ui(t, t, j);
fmpz_mod_ui(t, t, n);
result &= (fmpz_get_ui(t) == nmod_poly_get_coeff_ui(b, j - 1));
}
}
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);
}
fmpz_clear(t);
/* Check aliasing */
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_derivative(b, a);
nmod_poly_derivative(a, a);
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);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("shift_left_right....");
fflush(stdout);
/* Check a << shift >> shift == a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
slong 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)
{
flint_printf("FAIL:\n");
flint_printf("shift = %wd, a->length = %wd, n = %wu\n",
shift, a->length, a->mod.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);
}
/* Check a << shift >> shift == a aliasing the other way */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
mp_limb_t n = n_randtest_not_zero(state);
slong 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)
{
flint_printf("FAIL:\n");
flint_printf("shift = %wd, c->length = %wd, n = %wu\n",
shift, c->length, a->mod.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, 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;
}
~Flintzz_pX() { nmod_poly_clear(value); }
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;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_mul_nmod....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t c = n_randint(state, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_scalar_mul_nmod(b, a, c);
nmod_poly_scalar_mul_nmod(a, a, c);
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);
}
/* Check (a + b)*c = a*c + b*c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, d1, d2;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t c = n_randint(state, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(d1, n);
nmod_poly_init(d2, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_randtest(b, state, n_randint(state, 100));
nmod_poly_add(d1, a, b);
nmod_poly_scalar_mul_nmod(d1, d1, c);
nmod_poly_scalar_mul_nmod(d2, a, c);
nmod_poly_scalar_mul_nmod(b, b, c);
nmod_poly_add(d2, d2, b);
result = (nmod_poly_equal(d1, d2));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(d1), flint_printf("\n\n");
nmod_poly_print(d2), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(d1);
nmod_poly_clear(d2);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("make_monic....");
fflush(stdout);
/* Check new leading coeff = gcd old leading coeff and modulus */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t l;
nmod_poly_init(a, n);
nmod_poly_init(b, n);
if (n == 1) continue;
do { nmod_poly_randtest(a, state, n_randint(state, 100) + 1); } while (a->length == 0);
nmod_poly_make_monic(b, a);
l = n_gcd(a->mod.n, a->coeffs[a->length - 1]);
result = (l == b->coeffs[b->length - 1]);
if (!result)
{
printf("FAIL:\n");
printf("l = %lu, a->lead = %ld, n = %lu\n",
l, a->coeffs[a->length - 1], 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);
}
/* test aliasing */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t l;
nmod_poly_init(a, n);
if (n == 1) continue;
do { nmod_poly_randtest(a, state, n_randint(state, 100) + 1); } while (a->length == 0);
l = n_gcd(a->mod.n, a->coeffs[a->length - 1]);
nmod_poly_make_monic(a, a);
result = (l == a->coeffs[a->length - 1]);
if (!result)
{
printf("FAIL:\n");
printf("l = %lu, a->lead = %ld, n = %lu\n",
l, a->coeffs[a->length - 1], a->mod.n);
nmod_poly_print(a), printf("\n\n");
abort();
}
nmod_poly_clear(a);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
slong
nmod_poly_mat_nullspace(nmod_poly_mat_t res, const nmod_poly_mat_t mat)
{
slong i, j, k, n, rank, nullity;
slong * pivots;
slong * nonpivots;
nmod_poly_mat_t tmp;
nmod_poly_t den;
n = mat->c;
nmod_poly_init(den, nmod_poly_mat_modulus(mat));
nmod_poly_mat_init_set(tmp, mat);
rank = nmod_poly_mat_rref(tmp, den, tmp);
nullity = n - rank;
nmod_poly_mat_zero(res);
if (rank == 0)
{
for (i = 0; i < nullity; i++)
nmod_poly_one(res->rows[i] + i);
}
else if (nullity)
{
pivots = flint_malloc(rank * sizeof(slong));
nonpivots = flint_malloc(nullity * sizeof(slong));
for (i = j = k = 0; i < rank; i++)
{
while (nmod_poly_is_zero(tmp->rows[i] + j))
{
nonpivots[k] = j;
k++;
j++;
}
pivots[i] = j;
j++;
}
while (k < nullity)
{
nonpivots[k] = j;
k++;
j++;
}
nmod_poly_set(den, tmp->rows[0] + pivots[0]);
for (i = 0; i < nullity; i++)
{
for (j = 0; j < rank; j++)
nmod_poly_set(res->rows[pivots[j]] + i,
tmp->rows[j] + nonpivots[i]);
nmod_poly_neg(res->rows[nonpivots[i]] + i, den);
}
flint_free(pivots);
flint_free(nonpivots);
}
nmod_poly_clear(den);
nmod_poly_mat_clear(tmp);
return nullity;
}
void
nmod_poly_xgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T,
const nmod_poly_t A, const nmod_poly_t B)
{
const long lenA = A->length, lenB = B->length;
mp_limb_t inv;
if (lenA == 0)
{
if (lenB == 0)
{
nmod_poly_zero(G);
nmod_poly_zero(S);
nmod_poly_zero(T);
}
else
{
inv = n_invmod(B->coeffs[lenB - 1], B->mod.n);
nmod_poly_scalar_mul_nmod(G, B, inv);
nmod_poly_zero(S);
nmod_poly_set_coeff_ui(T, 0, inv);
T->length = 1;
}
}
else if (lenB == 0)
{
inv = n_invmod(A->coeffs[lenA - 1], A->mod.n);
nmod_poly_scalar_mul_nmod(G, A, inv);
nmod_poly_zero(T);
nmod_poly_set_coeff_ui(S, 0, inv);
S->length = 1;
}
else
{
nmod_poly_t tG, tS, tT;
mp_ptr g, s, t;
long lenG;
if (G == A || G == B)
{
nmod_poly_init2(tG, A->mod.n, FLINT_MIN(lenA, lenB));
g = tG->coeffs;
}
else
{
nmod_poly_fit_length(G, FLINT_MIN(lenA, lenB));
g = G->coeffs;
}
if (S == A || S == B)
{
nmod_poly_init2(tS, A->mod.n, lenB - 1);
s = tS->coeffs;
}
else
{
nmod_poly_fit_length(S, lenB - 1);
s = S->coeffs;
}
if (T == A || T == B)
{
nmod_poly_init2(tT, A->mod.n, lenA - 1);
t = tT->coeffs;
}
else
{
nmod_poly_fit_length(T, lenA - 1);
t = T->coeffs;
}
if (lenA >= lenB)
lenG = _nmod_poly_xgcd(g, s, t, A->coeffs, lenA,
B->coeffs, lenB, A->mod);
else
lenG = _nmod_poly_xgcd(g, t, s, B->coeffs, lenB,
A->coeffs, lenA, A->mod);
if (G == A || G == B)
{
nmod_poly_swap(tG, G);
nmod_poly_clear(tG);
}
if (S == A || S == B)
{
nmod_poly_swap(tS, S);
nmod_poly_clear(tS);
}
if (T == A || T == B)
{
nmod_poly_swap(tT, T);
nmod_poly_clear(tT);
}
G->length = lenG;
S->length = lenB - lenG;
T->length = lenA - lenG;
MPN_NORM(S->coeffs, S->length);
MPN_NORM(T->coeffs, T->length);
if (G->coeffs[lenG - 1] != 1)
{
inv = n_invmod(G->coeffs[lenG - 1], A->mod.n);
nmod_poly_scalar_mul_nmod(G, G, inv);
nmod_poly_scalar_mul_nmod(S, S, inv);
nmod_poly_scalar_mul_nmod(T, T, inv);
}
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("hensel_start_continue_lift....");
fflush(stdout);
flint_randinit(state);
/* We check that lifting local factors of F yields factors */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t F, G, H, R;
nmod_poly_factor_t f_fac;
fmpz_poly_factor_t F_fac;
long bits, nbits, n, exp, j, part_exp;
long r;
fmpz_poly_t *v, *w;
long *link;
long prev_exp;
bits = n_randint(state, 200) + 1;
nbits = n_randint(state, FLINT_BITS - 6) + 6;
fmpz_poly_init(F);
fmpz_poly_init(G);
fmpz_poly_init(H);
fmpz_poly_init(R);
nmod_poly_factor_init(f_fac);
fmpz_poly_factor_init(F_fac);
n = n_randprime(state, nbits, 0);
exp = bits / (FLINT_BIT_COUNT(n) - 1) + 1;
part_exp = n_randint(state, exp);
/* Produce F as the product of random G and H */
{
nmod_poly_t f;
nmod_poly_init(f, n);
do {
do {
fmpz_poly_randtest(G, state, n_randint(state, 200) + 2, bits);
} while (G->length < 2);
fmpz_randtest_not_zero(G->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(G));
do {
fmpz_poly_randtest(H, state, n_randint(state, 200) + 2, bits);
} while (H->length < 2);
fmpz_randtest_not_zero(H->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(H));
fmpz_poly_mul(F, G, H);
fmpz_poly_get_nmod_poly(f, F);
} while (!nmod_poly_is_squarefree(f));
fmpz_poly_get_nmod_poly(f, G);
nmod_poly_factor_insert(f_fac, f, 1);
fmpz_poly_get_nmod_poly(f, H);
nmod_poly_factor_insert(f_fac, f, 1);
nmod_poly_clear(f);
}
r = f_fac->num;
v = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
w = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
link = flint_malloc((2*r - 2)*sizeof(long));
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_init(v[j]);
fmpz_poly_init(w[j]);
}
if (part_exp < 1)
{
_fmpz_poly_hensel_start_lift(F_fac, link, v, w, F, f_fac, exp);
}
else
{
fmpz_t nn;
fmpz_init_set_ui(nn, n);
prev_exp = _fmpz_poly_hensel_start_lift(F_fac, link, v, w,
F, f_fac, part_exp);
_fmpz_poly_hensel_continue_lift(F_fac, link, v, w,
F, prev_exp, part_exp, exp, nn);
fmpz_clear(nn);
}
result = 1;
for (j = 0; j < F_fac->num; j++)
{
fmpz_poly_rem(R, F, F_fac->p + j);
result &= (R->length == 0);
}
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_clear(v[j]);
fmpz_poly_clear(w[j]);
}
flint_free(link);
flint_free(v);
flint_free(w);
if (!result)
{
printf("FAIL:\n");
printf("bits = %ld, n = %ld, exp = %ld\n", bits, n, exp);
fmpz_poly_print(F); printf("\n\n");
fmpz_poly_print(G); printf("\n\n");
fmpz_poly_print(H); printf("\n\n");
fmpz_poly_factor_print(F_fac); printf("\n\n");
abort();
}
nmod_poly_factor_clear(f_fac);
fmpz_poly_factor_clear(F_fac);
fmpz_poly_clear(F);
fmpz_poly_clear(H);
fmpz_poly_clear(G);
fmpz_poly_clear(R);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("mulmod....");
fflush(stdout);
/* Aliasing res and a */
for (i = 0; i < 500; i++)
{
nmod_poly_t a, b, res, t, f;
mp_limb_t n = n_randtest_prime(state, 0);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(f, n);
nmod_poly_init(res, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 50));
nmod_poly_randtest(b, state, n_randint(state, 50));
do {
nmod_poly_randtest(f, state, n_randint(state, 50));
} while (nmod_poly_is_zero(f));
nmod_poly_mulmod(res, a, b, f);
nmod_poly_mulmod(a, a, b, f);
result = (nmod_poly_equal(res, a));
if (!result)
{
printf("FAIL:\n");
printf("a:\n"); nmod_poly_print(a), printf("\n\n");
printf("b:\n"); nmod_poly_print(b), printf("\n\n");
printf("f:\n"); nmod_poly_print(f), printf("\n\n");
printf("res1:\n"); nmod_poly_print(res), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(f);
nmod_poly_clear(res);
nmod_poly_clear(t);
}
/* Aliasing res and b */
for (i = 0; i < 500; i++)
{
nmod_poly_t a, b, res, t, f;
mp_limb_t n = n_randtest_prime(state, 0);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(f, n);
nmod_poly_init(res, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 50));
nmod_poly_randtest(b, state, n_randint(state, 50));
do {
nmod_poly_randtest(f, state, n_randint(state, 50));
} while (nmod_poly_is_zero(f));
nmod_poly_mulmod(res, a, b, f);
nmod_poly_mulmod(b, a, b, f);
result = (nmod_poly_equal(res, b));
if (!result)
{
printf("FAIL:\n");
printf("a:\n"); nmod_poly_print(a), printf("\n\n");
printf("b:\n"); nmod_poly_print(b), printf("\n\n");
printf("f:\n"); nmod_poly_print(f), printf("\n\n");
printf("res1:\n"); nmod_poly_print(res), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(f);
nmod_poly_clear(res);
nmod_poly_clear(t);
}
/* Aliasing res and f */
for (i = 0; i < 500; i++)
{
nmod_poly_t a, b, res, t, f;
mp_limb_t n = n_randtest_prime(state, 0);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(f, n);
nmod_poly_init(res, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 50));
nmod_poly_randtest(b, state, n_randint(state, 50));
do {
nmod_poly_randtest(f, state, n_randint(state, 50));
} while (nmod_poly_is_zero(f));
nmod_poly_mulmod(res, a, b, f);
nmod_poly_mulmod(f, a, b, f);
result = (nmod_poly_equal(res, f));
if (!result)
{
printf("FAIL:\n");
printf("a:\n"); nmod_poly_print(a), printf("\n\n");
printf("b:\n"); nmod_poly_print(b), printf("\n\n");
printf("f:\n"); nmod_poly_print(f), printf("\n\n");
printf("res1:\n"); nmod_poly_print(res), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(f);
nmod_poly_clear(res);
nmod_poly_clear(t);
}
/* No aliasing */
for (i = 0; i < 1000; i++)
{
nmod_poly_t a, b, res1, res2, t, f;
mp_limb_t n = n_randtest_prime(state, 0);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(f, n);
nmod_poly_init(res1, n);
nmod_poly_init(res2, n);
nmod_poly_init(t, n);
nmod_poly_randtest(a, state, n_randint(state, 50));
nmod_poly_randtest(b, state, n_randint(state, 50));
do {
nmod_poly_randtest(f, state, n_randint(state, 50));
} while (nmod_poly_is_zero(f));
nmod_poly_mulmod(res1, a, b, f);
nmod_poly_mul(res2, a, b);
nmod_poly_divrem(t, res2, res2, f);
result = (nmod_poly_equal(res1, res2));
if (!result)
{
printf("FAIL:\n");
printf("a:\n"); nmod_poly_print(a), printf("\n\n");
printf("b:\n"); nmod_poly_print(b), printf("\n\n");
printf("f:\n"); nmod_poly_print(f), printf("\n\n");
printf("res1:\n"); nmod_poly_print(res1), printf("\n\n");
printf("res2:\n"); nmod_poly_print(res2), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(f);
nmod_poly_clear(res1);
nmod_poly_clear(res2);
nmod_poly_clear(t);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("taylor_shift_horner....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
nmod_poly_t f, g;
mp_limb_t c, mod;
mod = n_randtest_prime(state, 0);
nmod_poly_init(f, mod);
nmod_poly_init(g, mod);
nmod_poly_randtest(f, state, 1 + n_randint(state, 50));
c = n_randtest(state) % mod;
nmod_poly_taylor_shift_horner(g, f, c);
nmod_poly_taylor_shift_horner(f, f, c);
if (!nmod_poly_equal(g, f))
{
printf("FAIL\n");
nmod_poly_print(f); printf("\n");
nmod_poly_print(g); printf("\n");
abort();
}
nmod_poly_clear(f);
nmod_poly_clear(g);
}
/* Compare with composition */
for (i = 0; i < 10000; i++)
{
nmod_poly_t f, g, h1, h2;
mp_limb_t mod, c;
mod = n_randtest_prime(state, 0);
nmod_poly_init(f, mod);
nmod_poly_init(g, mod);
nmod_poly_init(h1, mod);
nmod_poly_init(h2, mod);
nmod_poly_randtest(f, state, 1 + n_randint(state, 50));
c = n_randtest(state) % mod;
nmod_poly_set_coeff_ui(g, 1, 1);
nmod_poly_set_coeff_ui(g, 0, c);
nmod_poly_taylor_shift_horner(h1, f, c);
nmod_poly_compose(h2, f, g);
if (!nmod_poly_equal(h1, h2))
{
printf("FAIL\n");
nmod_poly_print(f); printf("\n");
nmod_poly_print(g); printf("\n");
nmod_poly_print(h1); printf("\n");
nmod_poly_print(h2); printf("\n");
abort();
}
nmod_poly_clear(f);
nmod_poly_clear(g);
nmod_poly_clear(h1);
nmod_poly_clear(h2);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("mul....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 2000; 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(a, b, c);
nmod_poly_mul(b, b, c);
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);
nmod_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 2000; 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(a, b, c);
nmod_poly_mul(c, b, c);
result = (nmod_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(c), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
/* Check (b*c)+(b*d) = b*(c+d) */
for (i = 0; i < 2000; i++)
{
nmod_poly_t a1, a2, b, c, d;
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_init(d, n);
nmod_poly_randtest(b, state, n_randint(state, 100));
nmod_poly_randtest(c, state, n_randint(state, 100));
nmod_poly_randtest(d, state, n_randint(state, 100));
nmod_poly_mul(a1, b, c);
nmod_poly_mul(a2, b, d);
nmod_poly_add(a1, a1, a2);
nmod_poly_add(c, c, d);
nmod_poly_mul(a2, b, c);
result = (nmod_poly_equal(a1, a2));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(a1), printf("\n\n");
nmod_poly_print(a2), printf("\n\n");
abort();
}
nmod_poly_clear(a1);
nmod_poly_clear(a2);
nmod_poly_clear(b);
nmod_poly_clear(c);
nmod_poly_clear(d);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void
nmod_poly_divrem_basecase(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A,
const nmod_poly_t B)
{
const slong lenA = A->length, lenB = B->length;
mp_ptr Q_coeffs, R_coeffs, W;
nmod_poly_t t1, t2;
TMP_INIT;
if (lenB == 0)
{
flint_printf("Exception (nmod_poly_divrem). Division by zero.\n");
abort();
}
if (lenA < lenB)
{
nmod_poly_set(R, A);
nmod_poly_zero(Q);
return;
}
if (Q == A || Q == B)
{
nmod_poly_init2_preinv(t1, B->mod.n, B->mod.ninv, lenA - lenB + 1);
Q_coeffs = t1->coeffs;
}
else
{
nmod_poly_fit_length(Q, lenA - lenB + 1);
Q_coeffs = Q->coeffs;
}
if (R == A || R == B)
{
nmod_poly_init2_preinv(t2, B->mod.n, B->mod.ninv, lenB - 1);
R_coeffs = t2->coeffs;
}
else
{
nmod_poly_fit_length(R, lenB - 1);
R_coeffs = R->coeffs;
}
TMP_START;
W = TMP_ALLOC(NMOD_DIVREM_BC_ITCH(lenA, lenB, A->mod)*sizeof(mp_limb_t));
_nmod_poly_divrem_basecase(Q_coeffs, R_coeffs, W, A->coeffs, lenA,
B->coeffs, lenB, B->mod);
if (Q == A || Q == B)
{
nmod_poly_swap(Q, t1);
nmod_poly_clear(t1);
}
if (R == A || R == B)
{
nmod_poly_swap(R, t2);
nmod_poly_clear(t2);
}
Q->length = lenA - lenB + 1;
R->length = lenB - 1;
TMP_END;
_nmod_poly_normalise(R);
}
int
main(void)
{
int iter;
FLINT_TEST_INIT(state);
flint_printf("deflate....");
fflush(stdout);
for (iter = 0; iter < 100 * flint_test_multiplier(); iter++)
{
nmod_poly_t poly1, poly2, poly3;
mp_limb_t modulus;
ulong infl1, infl, deflation;
modulus = n_randtest_prime(state, 0);
nmod_poly_init(poly1, modulus);
nmod_poly_init(poly2, modulus);
nmod_poly_init(poly3, modulus);
nmod_poly_randtest(poly1, state, n_randint(state, 15));
if (nmod_poly_length(poly1) <= 1)
{
if (nmod_poly_deflation(poly1) != nmod_poly_length(poly1))
{
flint_printf("FAIL: wrong deflation for constant polynomial\n");
abort();
}
nmod_poly_deflate(poly2, poly1, n_randint(state, 5) + 1);
if (!nmod_poly_equal(poly2, poly1))
{
flint_printf("FAIL: constant polynomial changed on deflation\n");
abort();
}
}
else
{
infl = n_randint(state, 13) + 1;
infl1 = nmod_poly_deflation(poly1);
nmod_poly_inflate(poly2, poly1, infl);
deflation = nmod_poly_deflation(poly2);
if (deflation != infl * infl1)
{
flint_printf("FAIL: deflation = %wu, inflation: %wu, %wu\n",
deflation, infl, infl1);
flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n");
flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n");
abort();
}
nmod_poly_deflate(poly3, poly2, infl);
if (!nmod_poly_equal(poly3, poly1))
{
flint_printf("FAIL: deflation = %wu, inflation: %wu, %wu\n",
deflation, infl, infl1);
flint_printf("Deflated polynomial not equal to input:\n");
flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n");
flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n");
flint_printf("poly3:\n"); nmod_poly_print(poly2); flint_printf("\n\n");
abort();
}
nmod_poly_deflate(poly2, poly2, infl);
if (!nmod_poly_equal(poly3, poly2))
{
flint_printf("FAIL: aliasing\n");
abort();
}
}
nmod_poly_clear(poly1);
nmod_poly_clear(poly2);
nmod_poly_clear(poly3);
}
FLINT_TEST_CLEANUP(state);
flint_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("invsqrt_series....");
fflush(stdout);
/* Check 1/g^2 = h mod x^m */
for (i = 0; i < 1000; i++)
{
nmod_poly_t h, g, r;
long m;
mp_limb_t n;
do n = n_randtest_prime(state, 0);
while (n == 2UL);
nmod_poly_init(h, n);
nmod_poly_init(g, n);
nmod_poly_init(r, n);
do nmod_poly_randtest(h, state, n_randint(state, 1000));
while (h->length == 0);
nmod_poly_set_coeff_ui(h, 0, 1UL);
m = n_randint(state, h->length) + 1;
nmod_poly_invsqrt_series(g, h, m);
nmod_poly_mullow(r, g, g, m);
nmod_poly_inv_series(r, r, m);
nmod_poly_truncate(h, m);
result = (nmod_poly_equal(r, h));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(h), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(h);
nmod_poly_clear(g);
nmod_poly_clear(r);
}
/* Check aliasing of h and g */
for (i = 0; i < 1000; i++)
{
nmod_poly_t g, h;
long m;
mp_limb_t n;
do n = n_randtest_prime(state, 0);
while (n == 2UL);
nmod_poly_init(h, n);
nmod_poly_init(g, n);
do nmod_poly_randtest(h, state, n_randint(state, 500));
while (h->length == 0);
nmod_poly_set_coeff_ui(h, 0, 1UL);
m = n_randint(state, h->length) + 1;
nmod_poly_invsqrt_series(g, h, m);
nmod_poly_invsqrt_series(h, h, m);
result = (nmod_poly_equal(g, h));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(h), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld, m = %ld\n", n, m);
abort();
}
nmod_poly_clear(g);
nmod_poly_clear(h);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int iter;
flint_rand_t state;
flint_randinit(state);
printf("factor....");
fflush(stdout);
/* Default algorithm */
for (iter = 0; iter < 100; iter++)
{
int result = 1;
nmod_poly_t pol1, poly, quot, rem, product;
nmod_poly_factor_t res;
mp_limb_t modulus, lead = 1;
long length, num, i, j;
ulong exp[5], prod1;
modulus = n_randtest_prime(state, 0);
nmod_poly_init(pol1, modulus);
nmod_poly_init(poly, modulus);
nmod_poly_init(quot, modulus);
nmod_poly_init(rem, modulus);
nmod_poly_zero(pol1);
nmod_poly_set_coeff_ui(pol1, 0, 1);
length = n_randint(state, 7) + 2;
do
{
nmod_poly_randtest(poly, state, length);
if (poly->length)
nmod_poly_make_monic(poly, poly);
}
while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2));
exp[0] = n_randint(state, 30) + 1;
prod1 = exp[0];
for (i = 0; i < exp[0]; i++)
nmod_poly_mul(pol1, pol1, poly);
num = n_randint(state, 5) + 1;
for (i = 1; i < num; i++)
{
do
{
length = n_randint(state, 7) + 2;
nmod_poly_randtest(poly, state, length);
if (poly->length)
{
nmod_poly_make_monic(poly, poly);
nmod_poly_divrem(quot, rem, pol1, poly);
}
}
while ((!nmod_poly_is_irreducible(poly)) ||
(poly->length < 2) || (rem->length == 0));
exp[i] = n_randint(state, 30) + 1;
prod1 *= exp[i];
for (j = 0; j < exp[i]; j++)
nmod_poly_mul(pol1, pol1, poly);
}
nmod_poly_factor_init(res);
switch (n_randint(state, 3))
{
case 0:
lead = nmod_poly_factor(res, pol1);
break;
case 1:
lead = nmod_poly_factor_with_berlekamp(res, pol1);
break;
case 2:
if (modulus == 2)
lead = nmod_poly_factor(res, pol1);
else
lead = nmod_poly_factor_with_cantor_zassenhaus(res, pol1);
break;
}
result &= (res->num == num);
if (!result)
{
printf("Error: number of factors incorrect, %ld, %ld\n",
res->num, num);
abort();
}
nmod_poly_init(product, pol1->mod.n);
nmod_poly_set_coeff_ui(product, 0, 1);
for (i = 0; i < res->num; i++)
for (j = 0; j < res->exp[i]; j++)
nmod_poly_mul(product, product, res->p + i);
nmod_poly_scalar_mul_nmod(product, product, lead);
result &= nmod_poly_equal(pol1, product);
if (!result)
{
printf("Error: product of factors does not equal original polynomial\n");
nmod_poly_print(pol1); printf("\n");
nmod_poly_print(product); printf("\n");
abort();
}
nmod_poly_clear(product);
nmod_poly_clear(quot);
nmod_poly_clear(rem);
nmod_poly_clear(pol1);
nmod_poly_clear(poly);
nmod_poly_factor_clear(res);
}
/* Test deflation trick */
for (iter = 0; iter < 100; iter++)
{
nmod_poly_t pol1, poly, quot, rem;
nmod_poly_factor_t res, res2;
mp_limb_t modulus;
long length, num, i, j;
long exp[5], prod1;
ulong inflation;
int found;
do {
modulus = n_randtest_prime(state, 0);
} while (modulus == 2); /* To compare with CZ */
nmod_poly_init(pol1, modulus);
nmod_poly_init(poly, modulus);
nmod_poly_init(quot, modulus);
nmod_poly_init(rem, modulus);
nmod_poly_zero(pol1);
nmod_poly_set_coeff_ui(pol1, 0, 1);
inflation = n_randint(state, 7) + 1;
length = n_randint(state, 7) + 2;
do
{
nmod_poly_randtest(poly, state, length);
if (poly->length)
nmod_poly_make_monic(poly, poly);
}
while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2));
nmod_poly_inflate(poly, poly, inflation);
exp[0] = n_randint(state, 6) + 1;
prod1 = exp[0];
for (i = 0; i < exp[0]; i++)
nmod_poly_mul(pol1, pol1, poly);
num = n_randint(state, 5) + 1;
for (i = 1; i < num; i++)
{
do
{
length = n_randint(state, 6) + 2;
nmod_poly_randtest(poly, state, length);
if (poly->length)
{
nmod_poly_make_monic(poly, poly);
nmod_poly_divrem(quot, rem, pol1, poly);
}
}
while ((!nmod_poly_is_irreducible(poly)) ||
(poly->length < 2) || (rem->length == 0));
exp[i] = n_randint(state, 6) + 1;
prod1 *= exp[i];
nmod_poly_inflate(poly, poly, inflation);
for (j = 0; j < exp[i]; j++)
nmod_poly_mul(pol1, pol1, poly);
}
nmod_poly_factor_init(res);
nmod_poly_factor_init(res2);
switch (n_randint(state, 3))
{
case 0:
nmod_poly_factor(res, pol1);
break;
case 1:
nmod_poly_factor_with_berlekamp(res, pol1);
break;
case 2:
nmod_poly_factor_with_cantor_zassenhaus(res, pol1);
break;
}
nmod_poly_factor_cantor_zassenhaus(res2, pol1);
if (res->num != res2->num)
{
printf("FAIL: different number of factors found\n");
abort();
}
for (i = 0; i < res->num; i++)
{
found = 0;
for (j = 0; j < res2->num; j++)
{
if (nmod_poly_equal(res->p + i, res2->p + j) &&
res->exp[i] == res2->exp[j])
{
found = 1;
break;
}
}
if (!found)
{
printf("FAIL: factor not found\n");
abort();
}
}
nmod_poly_clear(quot);
nmod_poly_clear(rem);
nmod_poly_clear(pol1);
nmod_poly_clear(poly);
nmod_poly_factor_clear(res);
nmod_poly_factor_clear(res2);
}
flint_randclear(state);
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("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;
}
void embeddings_isomorphism_2(nmod_poly_t G, mp_srcptr F,
const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){
nmod_t mod = G->mod;
long m = nmod_poly_degree(FP->P);
long n = nmod_poly_degree(FQ->P);
long np = n + m - 1;
long p = ceil(sqrt(np));
long q = ceil((1.0*np)/p);
long i, j, k;
nmod_poly_t iT, iTm, T, X, tmp;
nmod_poly_struct *TT;
nmod_poly_init(iTm, mod.n);
nmod_poly_init(iT, mod.n);
nmod_poly_init(T, mod.n);
nmod_poly_init(X, mod.n);
nmod_poly_init(tmp, mod.n);
nmod_poly_mat_t MT, MH, MV;
nmod_poly_mat_init(MT, q, n, mod.n);
nmod_poly_mat_init(MH, p, q, mod.n);
nmod_poly_mat_init(MV, p, n, mod.n);
TT = flint_malloc(sizeof(nmod_poly_struct) * (q+1));
for (i = 0; i < q+1; i++)
nmod_poly_init(TT+i, mod.n);
nmod_poly_set_coeff_ui(X, 1, 1);
embeddings_embed(T, X, FQ, FP, FR);
nmod_poly_invmod(iT, T, FR->P);
nmod_poly_powmod_ui_binexp(iTm, iT, m-1, FR->P);
nmod_poly_zero(TT);
nmod_poly_set_coeff_ui(TT, 0, 1);
for (i = 1; i < q+1; i++)
nmod_poly_mulmod(TT+i, TT+(i-1), T, FR->P);
for (i = 0; i < q; i++)
for (j = 0; j < n; j++){
long jm = j*m;
for (k = 0; k < m; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MT, i, j), k, nmod_poly_get_coeff_ui(TT+i, k+jm));
}
for (i = 0; i < p; i++)
for (j = 0; j < q; j++){
long idx = i*q+j;
long lo = FLINT_MAX(0,m-1-idx);
long hi = FLINT_MIN(m,n+m-1-idx);
for (k = lo; k < hi; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MH, i, j), k, F[k*n+k+idx-m+1]);
}
nmod_poly_mat_mul(MV, MH, MT);
nmod_poly_zero(G);
for (i = p-1; i >= 0; i--){
nmod_poly_zero(tmp);
for (j = 0; j < n; j++){
long len = nmod_poly_mat_entry(MV, i, j)->length;
mp_ptr coefs = nmod_poly_mat_entry(MV, i, j)->coeffs;
long jm = j*m;
for (k = 0; k < len; k++)
nmod_poly_set_coeff_ui(tmp, k+jm, n_addmod(nmod_poly_get_coeff_ui(tmp, k+jm), coefs[k], mod.n));
}
nmod_poly_rem(tmp, tmp, FR->P);
nmod_poly_mulmod(G, G, TT+q, FR->P);
nmod_poly_add(G, G, tmp);
}
nmod_poly_mulmod(G, G, iTm, FR->P);
nmod_poly_clear(tmp);
nmod_poly_mat_clear(MT);
nmod_poly_mat_clear(MH);
nmod_poly_mat_clear(MV);
for (i = 0; i < q+1; i++)
nmod_poly_clear(TT+i);
flint_free(TT);
nmod_poly_clear(iTm);
nmod_poly_clear(iT);
nmod_poly_clear(T);
nmod_poly_clear(X);
}
