void nmod_poly_factor_set(nmod_poly_factor_t res, const nmod_poly_factor_t fac)
{
if (res != fac)
{
if (fac->num == 0)
{
nmod_poly_factor_clear(res);
nmod_poly_factor_init(res);
}
else
{
slong i;
nmod_poly_factor_fit_length(res, fac->num);
for (i = 0; i < fac->num; i++)
{
nmod_poly_set(res->p + i, fac->p + i);
(res->p + i)->mod = (fac->p + i)->mod;
res->exp[i] = fac->exp[i];
}
for ( ; i < res->num; i++)
{
nmod_poly_zero(res->p + i);
res->exp[i] = 0;
}
res->num = fac->num;
}
}
}
int main (void)
{
double t;
nmod_poly_t f, g, h;
for (int i= 15001;i < 16000; i++)
{
nmod_poly_init2 (f, 17, i/2+1);
nmod_poly_init2 (g, 17, i+1);
nmod_poly_set_coeff_ui (f, i/2, 1);
nmod_poly_set_coeff_ui (f, 1, 1);
nmod_poly_set_coeff_ui (f, 0, ((i%17)*(i%17)+3) % 17);
nmod_poly_set_coeff_ui (g, i, 1);
nmod_poly_set_coeff_ui (g, i/2+1, 1);
nmod_poly_set_coeff_ui (g, 1, ((i % 17)+1)%17);
nmod_poly_set_coeff_ui (g, 0, 15);
nmod_poly_init (h, 17);
nmod_poly_gcd (h, f, g);
if (!nmod_poly_is_one (h))
{
flint_printf ("i= %d\n", i);
nmod_poly_factor_t factors;
nmod_poly_factor_init (factors);
t= clock();
nmod_poly_factor (factors, h);
t = (clock() - t) / CLOCKS_PER_SEC;
flint_printf("factorization %.2lf\n", t);
nmod_poly_factor_clear (factors);
}
nmod_poly_clear (f);
nmod_poly_clear (g);
nmod_poly_clear (h);
}
return EXIT_SUCCESS;
}
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 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;
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;
}
