int _fmpq_poly_is_squarefree(const fmpz * poly, const fmpz_t den, long len)
{
if (len < 3)
return 1;
else if (len == 3)
{
int ans;
fmpz_t lhs, rhs;
fmpz_init(lhs);
fmpz_init(rhs);
fmpz_mul(lhs, poly + 1, poly + 1);
fmpz_mul(rhs, poly, poly + 2);
fmpz_mul_ui(rhs, rhs, 4);
ans = !fmpz_equal(lhs, rhs);
fmpz_clear(lhs);
fmpz_clear(rhs);
return ans;
}
else
{
long gdeg;
fmpz * w = _fmpz_vec_init(2 * len);
_fmpz_poly_derivative(w, poly, len);
_fmpz_poly_gcd(w + len, poly, len, w, len - 1L);
for (gdeg = len - 2L; w[gdeg] == 0L; gdeg--) ;
_fmpz_vec_clear(w, 2 * len);
return (gdeg == 0);
}
}
void _fmpq_poly_derivative(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, slong len)
{
_fmpz_poly_derivative(rpoly, poly, len);
fmpz_set(rden, den);
_fmpq_poly_canonicalise(rpoly, rden, len - 1);
}
void
_fmpz_poly_revert_series_newton(fmpz * Qinv, const fmpz * Q, long n)
{
if (n <= 2)
{
_fmpz_vec_set(Qinv, Q, n);
return;
}
else
{
long *a, i, k;
fmpz *T, *U, *V;
T = _fmpz_vec_init(n);
U = _fmpz_vec_init(n);
V = _fmpz_vec_init(n);
k = n;
for (i = 1; (1L << i) < k; i++);
a = (long *) flint_malloc(i * sizeof(long));
a[i = 0] = k;
while (k >= FLINT_REVERSE_NEWTON_CUTOFF)
a[++i] = (k = (k + 1) / 2);
_fmpz_poly_revert_series_lagrange(Qinv, Q, k);
_fmpz_vec_zero(Qinv + k, n - k);
for (i--; i >= 0; i--)
{
k = a[i];
_fmpz_poly_compose_series(T, Q, k, Qinv, k, k);
_fmpz_poly_derivative(U, T, k); fmpz_zero(U + k - 1);
fmpz_zero(T + 1);
_fmpz_poly_div_series(V, T, U, k);
_fmpz_poly_derivative(T, Qinv, k);
_fmpz_poly_mullow(U, V, k, T, k, k);
_fmpz_vec_sub(Qinv, Qinv, U, k);
}
flint_free(a);
_fmpz_vec_clear(T, n);
_fmpz_vec_clear(U, n);
_fmpz_vec_clear(V, n);
}
}
void
arb_rising2_ui_rs(arb_t u, arb_t v,
const arb_t x, ulong n, ulong m, slong prec)
{
if (n == 0)
{
arb_zero(v);
arb_one(u);
}
else if (n == 1)
{
arb_set(u, x);
arb_one(v);
}
else
{
slong wp;
ulong i, j, a, b;
arb_ptr xs;
arb_t S, T, U, V;
fmpz *A, *B;
wp = ARF_PREC_ADD(prec, FLINT_BIT_COUNT(n));
if (m == 0)
{
ulong m1, m2;
m1 = 0.6 * pow(wp, 0.4);
m2 = n_sqrt(n);
m = FLINT_MIN(m1, m2);
}
m = FLINT_MAX(m, 1);
xs = _arb_vec_init(m + 1);
A = _fmpz_vec_init(2 * m + 1);
B = A + (m + 1);
arb_init(S);
arb_init(T);
arb_init(U);
arb_init(V);
_arb_vec_set_powers(xs, x, m + 1, wp);
for (i = 0; i < n; i += m)
{
a = i;
b = FLINT_MIN(n, a + m);
if (a == 0 || b != a + m)
{
_gamma_rf_bsplit(A, a, b);
}
else
{
fmpz tt = m;
_fmpz_poly_taylor_shift(A, &tt, m + 1);
}
_fmpz_poly_derivative(B, A, b - a + 1);
arb_set_fmpz(S, A);
for (j = 1; j <= b - a; j++)
arb_addmul_fmpz(S, xs + j, A + j, wp);
arb_set_fmpz(T, B);
for (j = 1; j < b - a; j++)
arb_addmul_fmpz(T, xs + j, B + j, wp);
if (i == 0)
{
arb_set(U, S);
arb_set(V, T);
}
else
{
arb_mul(V, V, S, wp);
arb_addmul(V, U, T, wp);
arb_mul(U, U, S, wp);
}
}
arb_set(u, U);
arb_set(v, V);
_arb_vec_clear(xs, m + 1);
_fmpz_vec_clear(A, 2 * m + 1);
arb_clear(S);
arb_clear(T);
arb_clear(U);
arb_clear(V);
}
}
void _fmpz_poly_signature(long * r1, long * r2, fmpz * poly, long len)
{
fmpz *A, *B, *f, *g, *h, *w;
long lenA, lenB;
int s, t;
if (len <= 2)
{
*r1 = (len == 2);
*r2 = 0;
return;
}
w = _fmpz_vec_init(2 * len + 2);
A = w;
B = w + len;
lenA = len;
lenB = lenA - 1;
f = w + 2 * len - 1;
g = w + 2 * len;
h = w + 2 * len + 1;
_fmpz_poly_primitive_part(A, poly, lenA);
_fmpz_poly_derivative(B, A, lenA);
_fmpz_poly_primitive_part(B, B, lenB);
fmpz_one(g);
fmpz_one(h);
s = 1;
t = (lenA & 1L) ? -s : s;
*r1 = 1;
while (1)
{
long delta = lenA - lenB;
int sgnA;
_fmpz_poly_pseudo_rem_cohen(A, A, lenA, B, lenB);
lenA = lenB;
FMPZ_VEC_NORM(A, lenA);
if (lenA == 0)
{
printf("Exception: non-squarefree polynomial detected in fmpz_poly_signature\n");
_fmpz_vec_clear(w, 2 * len + 2);
abort();
}
if ((fmpz_sgn(B + (lenB - 1)) > 0) || (delta & 1L))
_fmpz_vec_neg(A, A, lenA);
sgnA = fmpz_sgn(A + (lenA - 1));
if (sgnA != s)
{
s = -s;
(*r1)--;
}
if (sgnA != ((lenA & 1L) ? t : -t))
{
t = -t;
(*r1)++;
}
if (lenA == 1)
{
*r2 = ((len - 1) - *r1) / 2;
_fmpz_vec_clear(w, 2 * len + 2);
return;
}
else
{
{
fmpz * temp = A;
A = B;
B = temp;
}
{
long temp = lenA;
lenA = lenB;
lenB = temp;
}
if (delta == 1)
{
fmpz_mul(f, g, h);
_fmpz_vec_scalar_divexact_fmpz(B, B, lenB, f);
fmpz_set(g, A + (lenA - 1));
fmpz_set(h, g);
}
else
{
fmpz_pow_ui(f, h, delta);
fmpz_mul(f, f, g);
_fmpz_vec_scalar_divexact_fmpz(B, B, lenB, f);
fmpz_pow_ui(f, h, delta - 1);
fmpz_pow_ui(g, A + (lenA - 1), delta);
fmpz_divexact(h, g, f);
fmpz_set(g, A + (lenA - 1));
}
}
}
}
int fmpq_poly_check_unique_real_root(const fmpq_poly_t pol, const arb_t a, slong prec)
{
if (pol->length < 2)
return 0;
else if (pol->length == 2)
{
/* linear polynomial */
fmpq_t root;
int ans;
fmpq_init(root);
fmpq_set_fmpz_frac(root, fmpq_poly_numref(pol), fmpq_poly_numref(pol) + 1);
fmpq_neg(root, root);
ans = arb_contains_fmpq(a, root);
fmpq_clear(root);
return ans;
}
else
{
arb_t b, c;
arf_t l, r;
fmpz * der;
int lsign, rsign;
fmpz_poly_t pol2;
slong n;
/* 1 - cheap test: */
/* - sign(left) * sign(right) = -1 */
/* - no zero of the derivative */
arb_init(b);
arb_init(c);
arf_init(l);
arf_init(r);
arb_get_interval_arf(l, r, a, prec);
arb_set_arf(b, l);
_fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec);
lsign = arb_sgn2(c);
arb_set_arf(b, r);
_fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec);
rsign = arb_sgn2(c);
arb_clear(c);
if (lsign * rsign == -1)
{
der = _fmpz_vec_init(pol->length - 1);
_fmpz_poly_derivative(der, pol->coeffs, pol->length);
_fmpz_poly_evaluate_arb(b, der, pol->length - 1, a, prec);
_fmpz_vec_clear(der, pol->length - 1);
if (!arb_contains_zero(b))
{
arf_clear(l);
arf_clear(r);
arb_clear(b);
return 1;
}
}
else
return 0;
arb_clear(b);
/* 2 - expensive testing */
fmpq_t ql, qr;
fmpq_init(ql);
fmpq_init(qr);
arf_get_fmpq(ql, l);
arf_get_fmpq(qr, r);
fmpz_poly_init(pol2);
fmpz_poly_fit_length(pol2, pol->length);
_fmpz_vec_set(pol2->coeffs, pol->coeffs, pol->length);
pol2->length = pol->length;
_fmpz_poly_scale_0_1_fmpq(pol2->coeffs, pol2->length, ql, qr);
n = fmpz_poly_num_real_roots_0_1(pol2);
fmpz_poly_clear(pol2);
fmpq_clear(ql);
fmpq_clear(qr);
return (n == 1);
}
}
