void
fmpz_poly_mat_pow(fmpz_poly_mat_t B, const fmpz_poly_mat_t A, ulong exp)
{
long d = fmpz_poly_mat_nrows(A);
if (exp == 0 || d == 0)
{
fmpz_poly_mat_one(B);
}
else if (exp == 1)
{
fmpz_poly_mat_set(B, A);
}
else if (exp == 2)
{
fmpz_poly_mat_sqr(B, A);
}
else if (d == 1)
{
fmpz_poly_pow(fmpz_poly_mat_entry(B, 0, 0),
fmpz_poly_mat_entry(A, 0, 0), exp);
}
else
{
fmpz_poly_mat_t T, U;
long i;
fmpz_poly_mat_init_set(T, A);
fmpz_poly_mat_init(U, d, d);
for (i = ((long) FLINT_BIT_COUNT(exp)) - 2; i >= 0; i--)
{
fmpz_poly_mat_sqr(U, T);
if (exp & (1L << i))
fmpz_poly_mat_mul(T, U, A);
else
fmpz_poly_mat_swap(T, U);
}
fmpz_poly_mat_swap(B, T);
fmpz_poly_mat_clear(T);
fmpz_poly_mat_clear(U);
}
}
void fmpz_poly_q_mul(fmpz_poly_q_t rop,
const fmpz_poly_q_t op1, const fmpz_poly_q_t op2)
{
if (fmpz_poly_q_is_zero(op1) || fmpz_poly_q_is_zero(op2))
{
fmpz_poly_q_zero(rop);
return;
}
if (op1 == op2)
{
fmpz_poly_pow(rop->num, op1->num, 2);
fmpz_poly_pow(rop->den, op1->den, 2);
return;
}
if (rop == op1 || rop == op2)
{
fmpz_poly_q_t t;
fmpz_poly_q_init(t);
fmpz_poly_q_mul(t, op1, op2);
fmpz_poly_q_swap(rop, t);
fmpz_poly_q_clear(t);
return;
}
/*
From here on, we may assume that rop, op1 and op2 refer to distinct
objects in memory, and that op1 and op2 are non-zero
*/
/* Polynomials? */
if (fmpz_poly_length(op1->den) == 1 && fmpz_poly_length(op2->den) == 1)
{
const slong len1 = fmpz_poly_length(op1->num);
const slong len2 = fmpz_poly_length(op2->num);
fmpz_poly_fit_length(rop->num, len1 + len2 - 1);
if (len1 >= len2)
{
_fmpq_poly_mul(rop->num->coeffs, rop->den->coeffs,
op1->num->coeffs, op1->den->coeffs, len1,
op2->num->coeffs, op2->den->coeffs, len2);
}
else
{
_fmpq_poly_mul(rop->num->coeffs, rop->den->coeffs,
op2->num->coeffs, op2->den->coeffs, len2,
op1->num->coeffs, op1->den->coeffs, len1);
}
_fmpz_poly_set_length(rop->num, len1 + len2 - 1);
_fmpz_poly_set_length(rop->den, 1);
return;
}
fmpz_poly_gcd(rop->num, op1->num, op2->den);
if (fmpz_poly_is_one(rop->num))
{
fmpz_poly_gcd(rop->den, op2->num, op1->den);
if (fmpz_poly_is_one(rop->den))
{
fmpz_poly_mul(rop->num, op1->num, op2->num);
fmpz_poly_mul(rop->den, op1->den, op2->den);
}
else
{
fmpz_poly_div(rop->num, op2->num, rop->den);
fmpz_poly_mul(rop->num, op1->num, rop->num);
fmpz_poly_div(rop->den, op1->den, rop->den);
fmpz_poly_mul(rop->den, rop->den, op2->den);
}
}
else
{
fmpz_poly_gcd(rop->den, op2->num, op1->den);
if (fmpz_poly_is_one(rop->den))
{
fmpz_poly_div(rop->den, op2->den, rop->num);
fmpz_poly_mul(rop->den, op1->den, rop->den);
fmpz_poly_div(rop->num, op1->num, rop->num);
fmpz_poly_mul(rop->num, rop->num, op2->num);
}
else
{
fmpz_poly_t t, u;
fmpz_poly_init(t);
fmpz_poly_init(u);
fmpz_poly_div(t, op1->num, rop->num);
fmpz_poly_div(u, op2->den, rop->num);
fmpz_poly_div(rop->num, op2->num, rop->den);
fmpz_poly_mul(rop->num, t, rop->num);
fmpz_poly_div(rop->den, op1->den, rop->den);
fmpz_poly_mul(rop->den, rop->den, u);
fmpz_poly_clear(t);
fmpz_poly_clear(u);
}
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pow_ui....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpz_poly */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong zbits1, rbits1, rbits2;
ulong e;
fmpz_poly_t A, B;
arb_poly_t a, b;
zbits1 = 2 + n_randint(state, 100);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
e = n_randint(state, 30);
fmpz_poly_init(A);
fmpz_poly_init(B);
arb_poly_init(a);
arb_poly_init(b);
fmpz_poly_randtest(A, state, 1 + n_randint(state, 8), zbits1);
fmpz_poly_pow(B, A, e);
arb_poly_set_fmpz_poly(a, A, rbits1);
arb_poly_pow_ui(b, a, e, rbits2);
if (!arb_poly_contains_fmpz_poly(b, B))
{
flint_printf("FAIL\n\n");
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("e = %wu\n", e);
flint_printf("A = "); fmpz_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpz_poly_print(B); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
abort();
}
arb_poly_pow_ui(a, a, e, rbits2);
if (!arb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpz_poly_clear(A);
fmpz_poly_clear(B);
arb_poly_clear(a);
arb_poly_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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("pow_multinomial....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
ulong exp;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 10), 100);
exp = n_randtest(state) % 20UL;
fmpz_poly_pow_multinomial(a, b, exp);
fmpz_poly_pow_multinomial(b, b, exp);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL(1):\n");
printf("exp = %lu\n", exp);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
/* Compare with fmpz_poly_pow */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b;
ulong exp;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_randtest(b, state, n_randint(state, 10), 100);
exp = n_randtest(state) % 20UL;
fmpz_poly_pow_multinomial(a, b, exp);
fmpz_poly_pow(b, b, exp);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL(2):\n");
printf("exp = %lu\n", exp);
printf("a = "), fmpz_poly_print(a), printf("\n\n");
printf("b = "), fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
var PowerPolyZ(const Tuple& x,uint e){
fmpz_poly_t res;
fmpz_poly_init(res);
fmpz_poly_pow(res,to_fmpz_poly(x),e);
return from_fmpz_poly(res);
}
