void fmpz_poly_factor_realloc(fmpz_poly_factor_t fac, long alloc)
{
if (alloc == 0) /* Clear up, reinitialise */
{
fmpz_poly_factor_clear(fac);
fmpz_poly_factor_init(fac);
}
else if (fac->alloc) /* Realloc */
{
if (fac->alloc > alloc)
{
long i;
for (i = alloc; i < fac->num; i++)
fmpz_poly_clear(fac->p + i);
fac->p = flint_realloc(fac->p, alloc * sizeof(fmpz_poly_struct));
fac->exp = flint_realloc(fac->exp, alloc * sizeof(long));
fac->alloc = alloc;
}
else if (fac->alloc < alloc)
{
long i;
fac->p = flint_realloc(fac->p, alloc * sizeof(fmpz_poly_struct));
fac->exp = flint_realloc(fac->exp, alloc * sizeof(long));
for (i = fac->alloc; i < alloc; i++)
{
fmpz_poly_init(fac->p + i);
fac->exp[i] = 0L;
}
fac->alloc = alloc;
}
}
else /* Nothing allocated already so do it now */
{
long i;
fac->p = flint_malloc(alloc * sizeof(fmpz_poly_struct));
fac->exp = flint_calloc(alloc, sizeof(long));
for (i = 0; i < alloc; i++)
fmpz_poly_init(fac->p + i);
fac->num = 0;
fac->alloc = alloc;
}
}
int main(int argc, char *argv[])
{
fmpz_poly_t f, g;
fmpz_poly_factor_t fac;
fmpz_t t;
slong compd, printd, i, j;
if (argc < 2)
{
flint_printf("poly_roots [-refine d] [-print d] <poly>\n\n");
flint_printf("Isolates all the complex roots of a polynomial with integer coefficients.\n\n");
flint_printf("If -refine d is passed, the roots are refined to an absolute tolerance\n");
flint_printf("better than 10^(-d). By default, the roots are only computed to sufficient\n");
flint_printf("accuracy to isolate them. The refinement is not currently done efficiently.\n\n");
flint_printf("If -print d is passed, the computed roots are printed to d decimals.\n");
flint_printf("By default, the roots are not printed.\n\n");
flint_printf("The polynomial can be specified by passing the following as <poly>:\n\n");
flint_printf("a <n> Easy polynomial 1 + 2x + ... + (n+1)x^n\n");
flint_printf("t <n> Chebyshev polynomial T_n\n");
flint_printf("u <n> Chebyshev polynomial U_n\n");
flint_printf("p <n> Legendre polynomial P_n\n");
flint_printf("c <n> Cyclotomic polynomial Phi_n\n");
flint_printf("s <n> Swinnerton-Dyer polynomial S_n\n");
flint_printf("b <n> Bernoulli polynomial B_n\n");
flint_printf("w <n> Wilkinson polynomial W_n\n");
flint_printf("e <n> Taylor series of exp(x) truncated to degree n\n");
flint_printf("m <n> <m> The Mignotte-like polynomial x^n + (100x+1)^m, n > m\n");
flint_printf("coeffs <c0 c1 ... cn> c0 + c1 x + ... + cn x^n\n\n");
flint_printf("Concatenate to multiply polynomials, e.g.: p 5 t 6 coeffs 1 2 3\n");
flint_printf("for P_5(x)*T_6(x)*(1+2x+3x^2)\n\n");
return 1;
}
compd = 0;
printd = 0;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_init(t);
fmpz_poly_one(f);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-refine"))
{
compd = atol(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "-print"))
{
printd = atol(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "a"))
{
slong n = atol(argv[i+1]);
fmpz_poly_zero(g);
for (j = 0; j <= n; j++)
fmpz_poly_set_coeff_ui(g, j, j+1);
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "t"))
{
arith_chebyshev_t_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "u"))
{
arith_chebyshev_u_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "p"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
arith_legendre_polynomial(h, atol(argv[i+1]));
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "c"))
{
arith_cyclotomic_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "s"))
{
arith_swinnerton_dyer_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "b"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
arith_bernoulli_polynomial(h, atol(argv[i+1]));
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "w"))
{
slong n = atol(argv[i+1]);
fmpz_poly_zero(g);
fmpz_poly_fit_length(g, n+2);
arith_stirling_number_1_vec(g->coeffs, n+1, n+2);
_fmpz_poly_set_length(g, n+2);
fmpz_poly_shift_right(g, g, 1);
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "e"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
fmpq_poly_set_coeff_si(h, 0, 0);
fmpq_poly_set_coeff_si(h, 1, 1);
fmpq_poly_exp_series(h, h, atol(argv[i+1]) + 1);
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "m"))
{
fmpz_poly_zero(g);
fmpz_poly_set_coeff_ui(g, 0, 1);
fmpz_poly_set_coeff_ui(g, 1, 100);
fmpz_poly_pow(g, g, atol(argv[i+2]));
fmpz_poly_set_coeff_ui(g, atol(argv[i+1]), 1);
fmpz_poly_mul(f, f, g);
i += 2;
}
else if (!strcmp(argv[i], "coeffs"))
{
fmpz_poly_zero(g);
i++;
j = 0;
while (i < argc)
{
if (fmpz_set_str(t, argv[i], 10) != 0)
{
i--;
break;
}
fmpz_poly_set_coeff_fmpz(g, j, t);
i++;
j++;
}
fmpz_poly_mul(f, f, g);
}
}
fmpz_poly_factor_init(fac);
flint_printf("computing squarefree factorization...\n");
TIMEIT_ONCE_START
fmpz_poly_factor_squarefree(fac, f);
TIMEIT_ONCE_STOP
TIMEIT_ONCE_START
for (i = 0; i < fac->num; i++)
{
flint_printf("roots with multiplicity %wd\n", fac->exp[i]);
fmpz_poly_complex_roots_squarefree(fac->p + i,
32, compd * 3.32193 + 2, printd);
}
TIMEIT_ONCE_STOP
fmpz_poly_factor_clear(fac);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_clear(t);
flint_cleanup();
return EXIT_SUCCESS;
}
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;
}
