void
nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, const nmod_poly_t f)
{
nmod_poly_t h, v, g, x;
slong i, j, num;
nmod_poly_init_preinv(h, f->mod.n, f->mod.ninv);
nmod_poly_init_preinv(g, f->mod.n, f->mod.ninv);
nmod_poly_init_preinv(v, f->mod.n, f->mod.ninv);
nmod_poly_init_preinv(x, f->mod.n, f->mod.ninv);
nmod_poly_set_coeff_ui(h, 1, 1);
nmod_poly_set_coeff_ui(x, 1, 1);
nmod_poly_make_monic(v, f);
i = 0;
do
{
i++;
nmod_poly_powmod_ui_binexp(h, h, f->mod.n, v);
nmod_poly_sub(h, h, x);
nmod_poly_gcd(g, h, v);
nmod_poly_add(h, h, x);
if (g->length != 1)
{
nmod_poly_make_monic(g, g);
num = res->num;
nmod_poly_factor_equal_deg(res, g, i);
for (j = num; j < res->num; j++)
res->exp[j] = nmod_poly_remove(v, res->p + j);
}
}
while (v->length >= 2*i + 3);
if (v->length > 1)
nmod_poly_factor_insert(res, v, 1);
nmod_poly_clear(g);
nmod_poly_clear(h);
nmod_poly_clear(v);
nmod_poly_clear(x);
}
void
nmod_poly_factor_squarefree(nmod_poly_factor_t res, const nmod_poly_t f)
{
nmod_poly_t f_d, g, g_1;
mp_limb_t p;
slong deg, i;
if (f->length <= 1)
{
res->num = 0;
return;
}
if (f->length == 2)
{
nmod_poly_factor_insert(res, f, 1);
return;
}
p = nmod_poly_modulus(f);
deg = nmod_poly_degree(f);
/* Step 1, look at f', if it is zero then we are done since f = h(x)^p
for some particular h(x), clearly f(x) = sum a_k x^kp, k <= deg(f) */
nmod_poly_init(g_1, p);
nmod_poly_init(f_d, p);
nmod_poly_init(g, p);
nmod_poly_derivative(f_d, f);
/* Case 1 */
if (nmod_poly_is_zero(f_d))
{
nmod_poly_factor_t new_res;
nmod_poly_t h;
nmod_poly_init(h, p);
for (i = 0; i <= deg / p; i++) /* this will be an integer since f'=0 */
{
nmod_poly_set_coeff_ui(h, i, nmod_poly_get_coeff_ui(f, i * p));
}
/* Now run square-free on h, and return it to the pth power */
nmod_poly_factor_init(new_res);
nmod_poly_factor_squarefree(new_res, h);
nmod_poly_factor_pow(new_res, p);
nmod_poly_factor_concat(res, new_res);
nmod_poly_clear(h);
nmod_poly_factor_clear(new_res);
}
else
{
nmod_poly_t h, z;
nmod_poly_gcd(g, f, f_d);
nmod_poly_div(g_1, f, g);
i = 1;
nmod_poly_init(h, p);
nmod_poly_init(z, p);
/* Case 2 */
while (!nmod_poly_is_one(g_1))
{
nmod_poly_gcd(h, g_1, g);
nmod_poly_div(z, g_1, h);
/* out <- out.z */
if (z->length > 1)
{
nmod_poly_factor_insert(res, z, 1);
nmod_poly_make_monic(res->p + (res->num - 1),
res->p + (res->num - 1));
if (res->num)
res->exp[res->num - 1] *= i;
}
i++;
nmod_poly_set(g_1, h);
nmod_poly_div(g, g, h);
}
nmod_poly_clear(h);
nmod_poly_clear(z);
nmod_poly_make_monic(g, g);
if (!nmod_poly_is_one(g))
{
/* so now we multiply res with square-free(g^1/p) ^ p */
nmod_poly_t g_p; /* g^(1/p) */
nmod_poly_factor_t new_res_2;
nmod_poly_init(g_p, p);
for (i = 0; i <= nmod_poly_degree(g) / p; i++)
nmod_poly_set_coeff_ui(g_p, i, nmod_poly_get_coeff_ui(g, i*p));
nmod_poly_factor_init(new_res_2);
/* square-free(g^(1/p)) */
nmod_poly_factor_squarefree(new_res_2, g_p);
nmod_poly_factor_pow(new_res_2, p);
nmod_poly_factor_concat(res, new_res_2);
nmod_poly_clear(g_p);
nmod_poly_factor_clear(new_res_2);
}
}
nmod_poly_clear(g_1);
nmod_poly_clear(f_d);
nmod_poly_clear(g);
}
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 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, 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;
}
