void _fmpz_poly_hensel_lift_without_inverse(fmpz *G, fmpz *H,
const fmpz *f, long lenF,
const fmpz *g, long lenG, const fmpz *h, long lenH,
const fmpz *a, long lenA, const fmpz *b, long lenB,
const fmpz_t p, const fmpz_t p1)
{
const fmpz one[1] = {1l};
const long lenM = FLINT_MAX(lenG, lenH);
const long lenE = FLINT_MAX(lenG + lenB - 2, lenH + lenA - 2);
const long lenD = FLINT_MAX(lenE, lenF);
fmpz *C, *D, *E, *M;
C = _fmpz_vec_init(lenF + lenD + lenE + lenM);
D = C + lenF;
E = D + lenD;
M = E + lenE;
if (lenG >= lenH)
_fmpz_poly_mul(C, g,lenG, h, lenH);
else
_fmpz_poly_mul(C, h, lenH, g, lenG);
_fmpz_vec_sub(C, f, C, lenF);
_fmpz_vec_scalar_divexact_fmpz(D, C, lenF, p);
_fmpz_vec_scalar_mod_fmpz(C, D, lenF, p1);
lift(G, g, lenG, b, lenB);
lift(H, h, lenH, a, lenA);
_fmpz_vec_clear(C, lenF + lenD + lenE + lenM);
}
void _fmpq_poly_canonicalise(fmpz * poly, fmpz_t den, slong len)
{
if (*den == WORD(1))
return;
if (*den == WORD(-1))
{
_fmpz_vec_neg(poly, poly, len);
fmpz_one(den);
}
else if (len == 0)
{
fmpz_one(den);
}
else
{
fmpz_t gcd;
fmpz_init(gcd);
_fmpz_vec_content(gcd, poly, len);
if (*gcd != WORD(1))
fmpz_gcd(gcd, gcd, den);
if (fmpz_sgn(den) < 0)
fmpz_neg(gcd, gcd);
if (*gcd != WORD(1))
{
_fmpz_vec_scalar_divexact_fmpz(poly, poly, len, gcd);
fmpz_divexact(den, den, gcd);
}
fmpz_clear(gcd);
}
}
void _fmpq_poly_scalar_div_si(fmpz * rpoly, fmpz_t rden, const fmpz * poly,
const fmpz_t den, long len, long c)
{
if (c == 1)
{
if (rpoly != poly)
{
_fmpz_vec_set(rpoly, poly, len);
fmpz_set(rden, den);
}
}
else if (c == -1)
{
_fmpz_vec_neg(rpoly, poly, len);
fmpz_set(rden, den);
}
else
{
fmpz_t d, f;
fmpz_init(d);
fmpz_init(f);
fmpz_set_si(f, c);
_fmpz_vec_content(d, poly, len);
fmpz_gcd(d, d, f);
if (c > 0)
{
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d);
fmpz_mul_si(rden, den, c / fmpz_get_si(d));
}
else
{
ulong q = (- (ulong) c) / fmpz_get_ui(d);
fmpz_neg(d, d);
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d);
fmpz_mul_ui(rden, den, q);
}
fmpz_clear(d);
fmpz_clear(f);
}
}
static void
_qadic_exp_bsplit(fmpz *y, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N)
{
const slong d = j[lena - 1];
const slong n = _padic_exp_bound(v, N, p);
if (n == 1)
{
fmpz_one(y + 0);
_fmpz_vec_zero(y + 1, d - 1);
}
else
{
fmpz *P, *T;
fmpz_t Q, R;
slong f;
P = _fmpz_vec_init(2*d - 1);
T = _fmpz_vec_init(2*d - 1);
fmpz_init(Q);
fmpz_init(R);
_qadic_exp_bsplit_series(P, Q, T, x, len, 1, n, a, j, lena);
fmpz_add(T + 0, T + 0, Q); /* (T,Q) := (T,Q) + 1 */
/* Note exp(x) is a unit so val(T) == val(Q). */
f = fmpz_remove(Q, Q, p);
fmpz_pow_ui(R, p, f);
_fmpz_vec_scalar_divexact_fmpz(T, T, d, R);
_padic_inv(Q, Q, p, N);
_fmpz_vec_scalar_mul_fmpz(y, T, d, Q);
_fmpz_vec_clear(P, 2*d - 1);
_fmpz_vec_clear(T, 2*d - 1);
fmpz_clear(Q);
fmpz_clear(R);
}
}
void
fmpz_poly_scalar_divexact_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2,
const fmpz_t x)
{
if (fmpz_is_zero(x))
{
printf("Exception: division by zero in fmpz_poly_scalar_divexact_fmpz\n");
abort();
}
if (poly2->length == 0)
{
fmpz_poly_zero(poly1);
return;
}
fmpz_poly_fit_length(poly1, poly2->length);
_fmpz_vec_scalar_divexact_fmpz(poly1->coeffs, poly2->coeffs, poly2->length, x);
_fmpz_poly_set_length(poly1, poly2->length);
}
void
_fmpz_poly_resultant(fmpz_t res, const fmpz * poly1, long len1,
const fmpz * poly2, long len2)
{
if (len2 == 1)
{
fmpz_pow_ui(res, poly2, len1 - 1);
}
else
{
fmpz_t a, b, g, h, t;
fmpz *A, *B, *W;
const long alloc = len1 + len2;
long sgn = 1;
fmpz_init(a);
fmpz_init(b);
fmpz_init(g);
fmpz_init(h);
fmpz_init(t);
A = W = _fmpz_vec_init(alloc);
B = W + len1;
_fmpz_poly_content(a, poly1, len1);
_fmpz_poly_content(b, poly2, len2);
_fmpz_vec_scalar_divexact_fmpz(A, poly1, len1, a);
_fmpz_vec_scalar_divexact_fmpz(B, poly2, len2, b);
fmpz_set_ui(g, 1);
fmpz_set_ui(h, 1);
fmpz_pow_ui(a, a, len2 - 1);
fmpz_pow_ui(b, b, len1 - 1);
fmpz_mul(t, a, b);
do
{
const long d = len1 - len2;
if (!(len1 & 1L) & !(len2 & 1L))
sgn = -sgn;
_fmpz_poly_pseudo_rem_cohen(A, A, len1, B, len2);
for (len1--; len1 >= 0 && !A[len1]; len1--) ;
len1++;
if (len1 == 0)
{
fmpz_zero(res);
goto cleanup;
}
{
fmpz * T;
long len;
T = A, A = B, B = T;
len = len1, len1 = len2, len2 = len;
}
fmpz_pow_ui(a, h, d);
fmpz_mul(b, g, a);
_fmpz_vec_scalar_divexact_fmpz(B, B, len2, b);
fmpz_pow_ui(g, A + (len1 - 1), d);
fmpz_mul(b, h, g);
fmpz_divexact(h, b, a);
fmpz_set(g, A + (len1 - 1));
} while (len2 > 1);
fmpz_pow_ui(g, h, len1 - 1);
fmpz_pow_ui(b, B + (len2 - 1), len1 - 1);
fmpz_mul(a, h, b);
fmpz_divexact(h, a, g);
fmpz_mul(res, t, h);
if (sgn < 0)
fmpz_neg(res, res);
cleanup:
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(g);
fmpz_clear(h);
fmpz_clear(t);
_fmpz_vec_clear(W, alloc);
}
}
void _fmpq_poly_scalar_div_mpq(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, long len,
const fmpz_t r, const fmpz_t s)
{
fmpz_t gcd1; /* GCD( poly, r ) */
fmpz_t gcd2; /* GCD( s, den ) */
fmpz_init(gcd1);
fmpz_init(gcd2);
fmpz_set_ui(gcd1, 1);
fmpz_set_ui(gcd2, 1);
if (*r != 1L)
{
_fmpz_vec_content(gcd1, poly, len);
if (*gcd1 != 1L)
fmpz_gcd(gcd1, gcd1, r);
}
if (*den != 1L && *s != 1L)
fmpz_gcd(gcd2, s, den);
if (*gcd1 == 1L)
{
if (*gcd2 == 1L)
{
_fmpz_vec_scalar_mul_fmpz(rpoly, poly, len, s);
fmpz_mul(rden, den, r);
}
else
{
fmpz_t s2;
fmpz_init(s2);
fmpz_divexact(s2, s, gcd2);
_fmpz_vec_scalar_mul_fmpz(rpoly, poly, len, s2);
fmpz_divexact(rden, den, gcd2);
fmpz_mul(rden, rden, r);
fmpz_clear(s2);
}
}
else
{
fmpz_t r2;
fmpz_init(r2);
fmpz_divexact(r2, r, gcd1);
if (*gcd2 == 1L)
{
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, gcd1);
_fmpz_vec_scalar_mul_fmpz(rpoly, rpoly, len, s);
fmpz_mul(rden, den, r2);
}
else
{
fmpz_t s2;
fmpz_init(s2);
fmpz_divexact(s2, s, gcd2);
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, gcd1);
_fmpz_vec_scalar_mul_fmpz(rpoly, rpoly, len, s2);
fmpz_divexact(rden, den, gcd2);
fmpz_mul(rden, rden, r2);
fmpz_clear(s2);
}
fmpz_clear(r2);
}
if (_fmpz_vec_is_zero(rpoly, len))
fmpz_set_ui(rden, 1);
if (fmpz_sgn(rden) < 0)
{
_fmpz_vec_neg(rpoly, rpoly, len);
fmpz_neg(rden, rden);
}
fmpz_clear(gcd1);
fmpz_clear(gcd2);
}
/* Assumes len1 != 0 != len2 */
int
_fmpz_poly_gcd_heuristic(fmpz * res, const fmpz * poly1, long len1,
const fmpz * poly2, long len2)
{
ulong bits1, bits2, max_bits, pack_bits, bound_bits, bits_G, bits_Q;
ulong limbs1, limbs2, limbsg, pack_limbs, qlimbs;
ulong log_glen, log_length;
long sign1, sign2, glen, qlen;
fmpz_t ac, bc, d, gc;
fmpz * A, * B, * G, * Q, * t;
mp_ptr array1, array2, arrayg, q, temp;
int divides;
fmpz_init(ac);
fmpz_init(bc);
fmpz_init(d);
/* compute gcd of content of poly1 and poly2 */
_fmpz_poly_content(ac, poly1, len1);
_fmpz_poly_content(bc, poly2, len2);
fmpz_gcd(d, ac, bc);
/* special case, one of the polys is a constant */
if (len2 == 1) /* if len1 == 1 then so does len2 */
{
fmpz_set(res, d);
fmpz_clear(ac);
fmpz_clear(bc);
fmpz_clear(d);
return 1;
}
/* divide poly1 and poly2 by their content */
A = _fmpz_vec_init(len1);
B = _fmpz_vec_init(len2);
_fmpz_vec_scalar_divexact_fmpz(A, poly1, len1, ac);
_fmpz_vec_scalar_divexact_fmpz(B, poly2, len2, bc);
fmpz_clear(ac);
fmpz_clear(bc);
/* special case, one of the polys is length 2 */
if (len2 == 2) /* if len1 == 2 then so does len2 */
{
Q = _fmpz_vec_init(len1 - len2 + 1);
if (_fmpz_poly_divides(Q, A, len1, B, 2))
{
_fmpz_vec_scalar_mul_fmpz(res, B, 2, d);
if (fmpz_sgn(res + 1) < 0)
_fmpz_vec_neg(res, res, 2);
}
else
{
fmpz_set(res, d);
fmpz_zero(res + 1);
}
fmpz_clear(d);
_fmpz_vec_clear(A, len1);
_fmpz_vec_clear(B, len2);
_fmpz_vec_clear(Q, len1 - len2 + 1);
return 1;
}
/*
Determine how many bits (pack_bits) to pack into. The bound
bound_bits ensures that if G | A and G | B with G primitive
then G is the gcd of A and B. The bound is taken from
http://arxiv.org/abs/cs/0206032v1
*/
bits1 = FLINT_ABS(_fmpz_vec_max_bits(A, len1));
bits2 = FLINT_ABS(_fmpz_vec_max_bits(B, len2));
max_bits = FLINT_MAX(bits1, bits2);
bound_bits = FLINT_MIN(bits1, bits2) + 6;
pack_bits = FLINT_MAX(bound_bits, max_bits); /* need to pack original polys */
pack_limbs = (pack_bits - 1)/FLINT_BITS + 1;
if (pack_bits >= 32) /* pack into multiples of limbs if >= 32 bits */
pack_bits = FLINT_BITS*pack_limbs;
/* allocate space to pack into */
limbs1 = (pack_bits*len1 - 1)/FLINT_BITS + 1;
limbs2 = (pack_bits*len2 - 1)/FLINT_BITS + 1;
array1 = flint_calloc(limbs1, sizeof(mp_limb_t));
array2 = flint_calloc(limbs2, sizeof(mp_limb_t));
arrayg = flint_calloc(limbs2, sizeof(mp_limb_t));
/* pack first poly and normalise */
sign1 = (long) fmpz_sgn(A + len1 - 1);
_fmpz_poly_bit_pack(array1, A, len1, pack_bits, sign1);
while (array1[limbs1 - 1] == 0) limbs1--;
/* pack second poly and normalise */
sign2 = (long) fmpz_sgn(B + len2 - 1);
_fmpz_poly_bit_pack(array2, B, len2, pack_bits, sign2);
while (array2[limbs2 - 1] == 0) limbs2--;
/* compute integer GCD */
limbsg = mpn_gcd_full(arrayg, array1, limbs1, array2, limbs2);
/*
Make space for unpacked gcd. May have one extra coeff due to
1 0 -x being packed as 0 -1 -x.
*/
glen = FLINT_MIN((limbsg*FLINT_BITS)/pack_bits + 1, len2);
G = _fmpz_vec_init(glen);
/* unpack gcd */
_fmpz_poly_bit_unpack(G, glen, arrayg, pack_bits, 0);
while (G[glen - 1] == 0) glen--;
/* divide by any content */
fmpz_init(gc);
_fmpz_poly_content(gc, G, glen);
if (!fmpz_is_one(gc))
limbsg = mpn_tdiv_q_fmpz_inplace(arrayg, limbsg, gc);
/* make space for quotient and remainder of first poly by gcd */
qlimbs = limbs1 - limbsg + 1;
qlen = FLINT_MIN(len1, (qlimbs*FLINT_BITS)/pack_bits + 1);
qlimbs = (qlen*pack_bits - 1)/FLINT_BITS + 1;
q = flint_calloc(qlimbs, sizeof(mp_limb_t));
temp = flint_malloc(limbsg*sizeof(mp_limb_t));
divides = 0;
if (mpn_divides(q, array1, limbs1, arrayg, limbsg, temp))
{
/* unpack quotient of first poly by gcd */
Q = _fmpz_vec_init(len1);
t = _fmpz_vec_init(len1 + glen);
_fmpz_poly_bit_unpack(Q, qlen, q, pack_bits, 0);
while (Q[qlen - 1] == 0) qlen--;
/* divide by content */
_fmpz_vec_scalar_divexact_fmpz(G, G, glen, gc);
/* check if we really need to multiply out to check for exact quotient */
bits_G = FLINT_ABS(_fmpz_vec_max_bits(G, glen));
bits_Q = FLINT_ABS(_fmpz_vec_max_bits(Q, qlen));
log_glen = FLINT_BIT_COUNT(glen);
log_length = FLINT_MIN(log_glen, FLINT_BIT_COUNT(qlen));
divides = (bits_G + bits_Q + log_length < pack_bits);
if (!divides) /* need to multiply out to check exact quotient */
divides = multiplies_out(A, len1, Q, qlen, G, glen, sign1, t);
if (divides) /* quotient really was exact */
{
mpn_zero(q, qlimbs);
if (mpn_divides(q, array2, limbs2, arrayg, limbsg, temp))
{
/* unpack quotient of second poly by gcd */
qlimbs = limbs2 - limbsg + 1;
qlen = FLINT_MIN(len2, (qlimbs*FLINT_BITS - 1)/pack_bits + 1);
_fmpz_poly_bit_unpack(Q, qlen, q, pack_bits, 0);
while (Q[qlen - 1] == 0) qlen--;
/* check if we really need to multiply out to check for exact quotient */
bits_Q = FLINT_ABS(_fmpz_vec_max_bits(Q, qlen));
log_length = FLINT_MIN(log_glen, FLINT_BIT_COUNT(qlen));
divides = (bits_G + bits_Q + log_length < pack_bits);
if (!divides) /* we need to multiply out */
divides = multiplies_out(B, len2, Q, qlen, G, glen, sign1, t);
}
}
_fmpz_vec_clear(t, len1 + glen);
_fmpz_vec_clear(Q, len1);
}
flint_free(q);
flint_free(temp);
flint_free(arrayg);
flint_free(array1);
flint_free(array2);
fmpz_clear(gc);
_fmpz_vec_clear(A, len1);
_fmpz_vec_clear(B, len2);
/* we found the gcd, so multiply by content */
if (divides)
{
_fmpz_vec_zero(res + glen, len2 - glen);
_fmpz_vec_scalar_mul_fmpz(res, G, glen, d);
}
fmpz_clear(d);
_fmpz_vec_clear(G, glen);
return divides;
}
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));
}
}
}
}
void _fmpq_poly_resultant(fmpz_t rnum, fmpz_t rden,
const fmpz *poly1, const fmpz_t den1, long len1,
const fmpz *poly2, const fmpz_t den2, long len2)
{
if (len2 == 1)
{
if (len1 == 1)
{
fmpz_one(rnum);
fmpz_one(rden);
}
else if (len1 == 2)
{
fmpz_set(rnum, poly2);
fmpz_set(rden, den2);
}
else
{
fmpz_pow_ui(rnum, poly2, len1 - 1);
if (fmpz_is_one(den2))
{
fmpz_one(rden);
}
else
{
fmpz_pow_ui(rden, den2, len1 - 1);
}
}
}
else /* len1 >= len2 >= 2 */
{
fmpz_t c1, c2;
fmpz *prim1, *prim2, *g;
long lenG = len2;
fmpz_init(c1);
fmpz_init(c2);
_fmpz_vec_content(c1, poly1, len1);
_fmpz_vec_content(c2, poly2, len2);
prim1 = _fmpz_vec_init(len1);
prim2 = _fmpz_vec_init(len2);
g = _fmpz_vec_init(len2);
_fmpz_vec_scalar_divexact_fmpz(prim1, poly1, len1, c1);
_fmpz_vec_scalar_divexact_fmpz(prim2, poly2, len2, c2);
_fmpz_poly_gcd(g, prim1, len1, prim2, len2);
FMPZ_VEC_NORM(g, lenG);
if (lenG > 1)
{
fmpz_zero(rnum);
fmpz_one(rden);
}
else /* prim1, prim2 are coprime */
{
fmpz_t t;
fmpz_init(t);
_fmpz_poly_resultant(rnum, prim1, len1, prim2, len2);
if (!fmpz_is_one(c1))
{
fmpz_pow_ui(t, c1, len2 - 1);
fmpz_mul(rnum, rnum, t);
}
if (!fmpz_is_one(c2))
{
fmpz_pow_ui(t, c2, len1 - 1);
fmpz_mul(rnum, rnum, t);
}
if (fmpz_is_one(den1))
{
if (fmpz_is_one(den2))
fmpz_one(rden);
else
fmpz_pow_ui(rden, den2, len1 - 1);
}
else
{
if (fmpz_is_one(den2))
fmpz_pow_ui(rden, den1, len2 - 1);
else
{
fmpz_pow_ui(rden, den1, len2 - 1);
fmpz_pow_ui(t, den2, len1 - 1);
fmpz_mul(rden, rden, t);
}
}
_fmpq_canonicalise(rnum, rden);
fmpz_clear(t);
}
fmpz_clear(c1);
fmpz_clear(c2);
_fmpz_vec_clear(prim1, len1);
_fmpz_vec_clear(prim2, len2);
_fmpz_vec_clear(g, len2);
}
}
