static void
bsplit_recursive_fmpz(fmpz_t P, fmpz_t Q, fmpz_t B, fmpz_t T,
const hypgeom_t hyp, long a, long b, int cont)
{
if (b - a == 1)
{
if (a == 0)
{
fmpz_one(P);
fmpz_one(Q);
}
else
{
fmpz_poly_evaluate_si(P, hyp->P, a);
fmpz_poly_evaluate_si(Q, hyp->Q, a);
}
fmpz_poly_evaluate_si(B, hyp->B, a);
fmpz_poly_evaluate_si(T, hyp->A, a);
fmpz_mul(T, T, P);
}
else
{
long m;
fmpz_t P2, Q2, B2, T2;
m = (a + b) / 2;
fmpz_init(P2);
fmpz_init(Q2);
fmpz_init(B2);
fmpz_init(T2);
bsplit_recursive_fmpz(P, Q, B, T, hyp, a, m, 1);
bsplit_recursive_fmpz(P2, Q2, B2, T2, hyp, m, b, 1);
if (fmpz_is_one(B) && fmpz_is_one(B2))
{
fmpz_mul(T, T, Q2);
fmpz_addmul(T, P, T2);
}
else
{
fmpz_mul(T, T, B2);
fmpz_mul(T, T, Q2);
fmpz_mul(T2, T2, B);
fmpz_addmul(T, P, T2);
}
fmpz_mul(B, B, B2);
fmpz_mul(Q, Q, Q2);
if (cont)
fmpz_mul(P, P, P2);
fmpz_clear(P2);
fmpz_clear(Q2);
fmpz_clear(B2);
fmpz_clear(T2);
}
}
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
_nf_elem_mod_fmpz(nf_elem_t res, const nf_elem_t a, const fmpz_t mod, const nf_t nf)
{
if (nf_elem_is_zero(a, nf))
{
nf_elem_zero(res, nf);
return;
}
if (nf->flag & NF_LINEAR)
{
fmpz_mod(LNF_ELEM_NUMREF(res), LNF_ELEM_NUMREF(a), mod);
fmpz_one(LNF_ELEM_DENREF(res));
}
else if (nf->flag & NF_QUADRATIC)
{
_fmpz_vec_scalar_mod_fmpz(QNF_ELEM_NUMREF(res), QNF_ELEM_NUMREF(a), 3, mod);
fmpz_one(QNF_ELEM_DENREF(res));
}
else
{
fmpq_poly_fit_length(NF_ELEM(res), fmpq_poly_length(NF_ELEM(a)));
_fmpq_poly_set_length(NF_ELEM(res), fmpq_poly_length(NF_ELEM(a)));
_fmpz_vec_scalar_mod_fmpz(NF_ELEM(res)->coeffs, NF_ELEM(a)->coeffs, fmpq_poly_length(NF_ELEM(a)), mod);
fmpz_one(NF_ELEM_DENREF(res));
}
nf_elem_canonicalise(res, nf);
}
void _fmpq_poly_scalar_mul_fmpz(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, long len,
const fmpz_t c)
{
fmpz_t gcd; /* GCD( den, c ) */
if (fmpz_is_zero(c))
{
_fmpz_vec_zero(rpoly, len);
fmpz_one(rden);
return;
}
fmpz_init(gcd);
fmpz_one(gcd);
if (*c != 1L)
fmpz_gcd(gcd, c, den);
if (*gcd == 1L)
{
_fmpz_vec_scalar_mul_fmpz(rpoly, poly, len, c);
fmpz_set(rden, den);
}
else
{
fmpz_t c2;
fmpz_init(c2);
fmpz_divexact(c2, c, gcd);
_fmpz_vec_scalar_mul_fmpz(rpoly, poly, len, c2);
fmpz_divexact(rden, den, gcd);
fmpz_clear(c2);
}
fmpz_clear(gcd);
}
int
fmpz_mat_inv(fmpz_mat_t B, fmpz_t den, const fmpz_mat_t A)
{
long dim = A->r;
if (dim == 0)
{
fmpz_one(den);
return 1;
}
else if (dim == 1)
{
fmpz_set(den, A->entries);
fmpz_one(B->entries);
return !fmpz_is_zero(den);
}
else if (dim == 2)
{
_fmpz_mat_inv_2x2(B->rows, den, A->rows);
return !fmpz_is_zero(den);
}
else
{
fmpz_mat_t I;
long i;
int success;
fmpz_mat_init(I, dim, dim);
for (i = 0; i < dim; i++)
fmpz_one(fmpz_mat_entry(I, i, i));
success = fmpz_mat_solve_fflu(B, den, A, I);
fmpz_mat_clear(I);
return success;
}
}
void sample(void * arg, ulong count)
{
info_t * info = (info_t *) arg;
slong length = info->length, i, j;
int monic = info->monic;
int scale;
scale = 1000;
if (length >= 50) scale = 100;
if (length >= 500) scale = 40;
flint_rand_t state;
flint_randinit(state);
fmpq_poly_t pol;
nf_t nf;
nf_elem_t a;
fmpq_t norm;
fmpq_poly_init(pol);
fmpq_init(norm);
for (i = 0; i < count; i++)
{
random_fmpq_poly(pol, state, length);
if (monic)
{
fmpz_one(fmpq_poly_denref(pol));
fmpq_poly_set_coeff_ui(pol, length - 1, 1);
}
nf_init(nf, pol);
nf_elem_init(a, nf);
random_nf_elem(a, state, nf);
if (monic)
fmpz_one(fmpq_poly_denref(NF_ELEM(a)));
prof_start();
for (j = 0; j < scale; j++)
{
nf_elem_trace(norm, a, nf);
}
prof_stop();
}
fmpq_clear(norm);
nf_elem_clear(a, nf);
nf_clear(nf);
fmpq_poly_clear(pol);
flint_randclear(state);
}
static void dsum_p(
fmpz_t rop,
const fmpz *dinv, const fmpz *mu, long M, const long *C, long lenC,
const fmpz_t a, long ui, long vi, long n, long d, long p, long N)
{
long m, r, idx;
fmpz_t apm1, apow, f, g, P, PN;
fmpz_init(apm1);
fmpz_init(apow);
fmpz_init(f);
fmpz_init(g);
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_zero(rop);
r = 0;
m = (p * (ui + 1) - (vi + 1)) / d;
if (m <= M) /* Step {r = 0} */
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_powm_ui(apm1, a, p - 1, PN);
fmpz_one(apow);
fmpz_one(f);
fmpz_mod(rop, mu + idx + lenC * (m / p), PN);
}
for (r = 1, m += p; m <= M; r++, m += p)
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_mul(apow, apow, apm1);
fmpz_mod(apow, apow, PN);
fmpz_mul_ui(f, f, ui + 1 + (r - 1) * d);
fmpz_mod(f, f, PN);
fmpz_mul(g, f, dinv + r);
fmpz_mul(g, g, apow);
fmpz_mul(g, g, mu + idx + lenC * (m / p));
fmpz_mod(g, g, PN);
fmpz_add(rop, rop, g);
}
fmpz_mod(rop, rop, PN);
fmpz_clear(apm1);
fmpz_clear(apow);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(P);
fmpz_clear(PN);
}
void _fmpq_poly_div(fmpz * Q, fmpz_t q,
const fmpz * A, const fmpz_t a, long lenA,
const fmpz * B, const fmpz_t b, long lenB)
{
long lenQ = lenA - lenB + 1;
ulong d;
const fmpz * lead = B + (lenB - 1);
if (lenB == 1)
{
_fmpq_poly_scalar_div_fmpq(Q, q, A, a, lenA, B, b);
return;
}
/*
From pseudo division over Z we have
lead^d * A = Q * B + R
and thus
{A, a} = {b * Q, a * lead^d} * {B, b} + {R, a * lead^d}.
*/
_fmpz_poly_pseudo_div(Q, &d, A, lenA, B, lenB);
/* 1. lead^d == +-1. {Q, q} = {b Q, a} up to sign */
if (d == 0UL || *lead == 1L || *lead == -1L)
{
fmpz_one(q);
_fmpq_poly_scalar_mul_fmpz(Q, q, Q, q, lenQ, b);
_fmpq_poly_scalar_div_fmpz(Q, q, Q, q, lenQ, a);
if (*lead == -1L && d % 2UL)
_fmpz_vec_neg(Q, Q, lenQ);
}
/* 2. lead^d != +-1. {Q, q} = {b Q, a lead^d} */
else
{
/*
TODO: Improve this. Clearly we do not need to compute
den = a lead^d in many cases, but can determine the GCD from
lead alone already.
*/
fmpz_t den;
fmpz_init(den);
fmpz_pow_ui(den, lead, d);
fmpz_mul(den, a, den);
fmpz_one(q);
_fmpq_poly_scalar_mul_fmpz(Q, q, Q, q, lenQ, b);
_fmpq_poly_scalar_div_fmpz(Q, q, Q, q, lenQ, den);
fmpz_clear(den);
}
}
void
_gamma_rf_bsplit(fmpz * A, ulong a, ulong b)
{
ulong n = b - a;
if (n == 0)
{
fmpz_one(A);
}
else if (n < 8)
{
ulong j, k;
fmpz_set_ui(A, a);
fmpz_one(A + 1);
for (j = 1; j < n; j++)
{
fmpz_one(A + j + 1);
for (k = j; k > 0; k--)
{
fmpz_mul_ui(A + k, A + k, a + j);
fmpz_add(A + k, A + k, A + k - 1);
}
fmpz_mul_ui(A, A, a + j);
}
}
else
{
ulong m = a + (b - a) / 2;
ulong w = m - a;
ulong v = b - m;
fmpz *t, *A1, *A2;
t = _fmpz_vec_init(w + v + 2);
A1 = t;
A2 = A1 + w + 1;
_gamma_rf_bsplit(A1, a, m);
_gamma_rf_bsplit(A2, m, b);
_fmpz_poly_mul(A, A2, v + 1, A1, w + 1);
_fmpz_vec_clear(t, w + v + 2);
}
}
void
_fmpz_poly_pow_binomial(fmpz * res, const fmpz * poly, ulong e)
{
ulong i, f;
fmpz_t a, b, c;
*a = 1L;
*b = 1L;
*c = 1L;
fmpz_one(res);
fmpz_one(res + e);
for (i = 1UL, f = e - 1UL; i <= (e - 1UL) >> 1; i++, f--)
{
fmpz_mul(a, a, poly);
fmpz_mul(b, b, poly + 1);
fmpz_mul_ui(c, c, f + 1UL);
fmpz_divexact_ui(c, c, i);
fmpz_mul(res + i, b, c);
fmpz_mul(res + f, a, c);
}
if ((e & 1UL) == 0UL)
{
fmpz_mul(a, a, poly);
fmpz_mul(b, b, poly + 1);
fmpz_mul_ui(c, c, f + 1UL);
fmpz_divexact_ui(c, c, i);
fmpz_mul(res + i, b, c);
fmpz_mul(res + i, res + i, a);
i++, f--;
}
for ( ; i <= e; i++, f--)
{
fmpz_mul(a, a, poly);
fmpz_mul(b, b, poly + 1);
fmpz_mul(res + i, res + i, b);
fmpz_mul(res + f, res + f, a);
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
int
fmpz_mat_solve_cramer(fmpz_mat_t X, fmpz_t den,
const fmpz_mat_t A, const fmpz_mat_t B)
{
long i, dim = fmpz_mat_nrows(A);
if (dim == 0)
{
fmpz_one(den);
return 1;
}
else if (dim == 1)
{
fmpz_set(den, fmpz_mat_entry(A, 0, 0));
if (fmpz_is_zero(den))
return 0;
if (!fmpz_mat_is_empty(B))
_fmpz_vec_set(X->rows[0], B->rows[0], fmpz_mat_ncols(B));
return 1;
}
else if (dim == 2)
{
fmpz_t t, u;
_fmpz_mat_det_cofactor_2x2(den, A->rows);
if (fmpz_is_zero(den))
return 0;
fmpz_init(t);
fmpz_init(u);
for (i = 0; i < fmpz_mat_ncols(B); i++)
{
fmpz_mul (t, fmpz_mat_entry(A, 1, 1), fmpz_mat_entry(B, 0, i));
fmpz_submul(t, fmpz_mat_entry(A, 0, 1), fmpz_mat_entry(B, 1, i));
fmpz_mul (u, fmpz_mat_entry(A, 0, 0), fmpz_mat_entry(B, 1, i));
fmpz_submul(u, fmpz_mat_entry(A, 1, 0), fmpz_mat_entry(B, 0, i));
fmpz_swap(fmpz_mat_entry(X, 0, i), t);
fmpz_swap(fmpz_mat_entry(X, 1, i), u);
}
fmpz_clear(t);
fmpz_clear(u);
return 1;
}
else if (dim == 3)
{
return _fmpz_mat_solve_cramer_3x3(X, den, A, B);
}
else
{
printf("Exception: fmpz_mat_solve_cramer: dim > 3 not implemented");
abort();
}
}
void _fmpq_poly_scalar_mul_ui(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, slong len,
ulong c)
{
fmpz_t gcd; /* GCD( den, c ) */
if (c == 0)
{
_fmpz_vec_zero(rpoly, len);
fmpz_one(rden);
return;
}
fmpz_init(gcd);
fmpz_set_ui(gcd, c);
fmpz_gcd(gcd, gcd, den);
if (*gcd == WORD(1))
{
_fmpz_vec_scalar_mul_ui(rpoly, poly, len, c);
fmpz_set(rden, den);
}
else
{
ulong gcd2 = fmpz_get_ui(gcd);
ulong c2 = c / gcd2;
_fmpz_vec_scalar_mul_ui(rpoly, poly, len, c2);
fmpz_fdiv_q_ui(rden, den, gcd2);
}
fmpz_clear(gcd);
}
void
_acb_poly_binomial_transform_basecase(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec)
{
slong n, k;
fmpz_t t;
fmpz_init(t);
for (n = 0; n < len; n++)
{
acb_zero(b + n);
for (k = 0; k < FLINT_MIN(n + 1, alen); k++)
{
if (k == 0)
{
fmpz_one(t);
}
else
{
fmpz_mul_si(t, t, -(n - k + 1));
fmpz_divexact_ui(t, t, k);
}
acb_addmul_fmpz(b + n, a + k, t, prec);
}
}
fmpz_clear(t);
}
void
fmpz_holonomic_forward_fmpz_mat(fmpz_mat_t M, fmpz_t Q,
const fmpz_holonomic_t op, long start, long n)
{
long r = fmpz_holonomic_order(op);
if (r == 0 || n == 0)
{
fmpz_mat_one(M);
fmpz_one(Q);
return;
}
if (n < 0)
{
abort();
}
if (fmpz_holonomic_seq_is_cfinite(op))
{
_fmpz_holonomic_eval_companion_matrix_fmpz(M, Q, op, 0);
fmpz_mat_pow(M, M, n);
fmpz_pow_ui(Q, Q, n);
}
else if (fmpz_holonomic_seq_is_hypgeom(op))
{
_fmpz_holonomic_bsplit_hypgeom_fmpz(M->rows[0], Q,
op->coeffs, op->coeffs + 1, start, 0, n);
}
else
{
_fmpz_holonomic_forward_bsplit_fmpz(M, Q, op, start, 0, n);
}
}
static void precompute_dinv_p(fmpz *list, long M, long d, long p, long N)
{
fmpz_one(list + 0);
if (M >= p)
{
fmpz_t P, PN;
long r;
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_set_ui(list + 1, d);
_padic_inv(list + 1, list + 1, P, N);
for (r = 2; r <= M / p; r++)
{
fmpz_mul(list + r, list + (r - 1), list + 1);
fmpz_mod(list + r, list + r, PN);
}
fmpz_clear(P);
fmpz_clear(PN);
}
}
void
_fmpq_poly_compose(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1,
long len1, const fmpz * poly2, const fmpz_t den2, long len2)
{
if (*den2 == 1L)
{
_fmpz_poly_compose(res, poly1, len1, poly2, len2);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, (len1 - 1L) * (len2 - 1L) + 1L);
}
else
{
fmpz_t one;
fmpz * v = _fmpz_vec_init(len1);
fmpz_init(one);
fmpz_one(one);
_fmpq_poly_rescale(v, den, poly1, den1, len1, one, den2);
_fmpz_poly_compose(res, v, len1, poly2, len2);
_fmpq_poly_canonicalise(res, den, (len1 - 1L) * (len2 - 1L) + 1L);
fmpz_clear(one);
_fmpz_vec_clear(v, len1);
}
}
int
fmpz_mat_solve_fflu(fmpz_mat_t X, fmpz_t den,
const fmpz_mat_t A, const fmpz_mat_t B)
{
fmpz_mat_t LU;
long dim, *perm;
int result;
if (fmpz_mat_is_empty(A) || fmpz_mat_is_empty(B))
{
fmpz_one(den);
return 1;
}
dim = fmpz_mat_nrows(A);
perm = _perm_init(dim);
fmpz_mat_init_set(LU, A);
result = (fmpz_mat_fflu(LU, den, perm, LU, 1) == dim);
if (result)
fmpz_mat_solve_fflu_precomp(X, perm, LU, B);
else
fmpz_zero(den);
_perm_clear(perm);
fmpz_mat_clear(LU);
return result;
}
void padic_val_fac(fmpz_t rop, const fmpz_t op, const fmpz_t p)
{
fmpz_t t, q, pow;
if (fmpz_sgn(op) <= 0)
{
printf("Exception (padic_val_fac). op is non-positive.\n");
abort();
}
fmpz_init(t);
fmpz_init(q);
fmpz_init(pow);
fmpz_one(pow);
do
{
fmpz_mul(pow, pow, p);
fmpz_fdiv_q(q, op, pow);
fmpz_add(t, t, q);
}
while (!fmpz_is_zero(q));
fmpz_swap(rop, t);
fmpz_clear(t);
fmpz_clear(q);
fmpz_clear(pow);
}
void _fmpq_poly_integral(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, slong len)
{
slong k;
fmpz_t t;
fmpz_init(t);
fmpz_one(t);
for (k = len - 1; k > 0; k--)
{
fmpz_mul(rpoly + k, poly + k - 1, t);
fmpz_mul_ui(t, t, k);
}
fmpz_mul(rden, den, t);
fmpz_set_ui(t, UWORD(2));
for (k = 3; k < len; k++)
{
fmpz_mul(rpoly + k, rpoly + k, t);
fmpz_mul_ui(t, t, k);
}
fmpz_zero(rpoly);
_fmpq_poly_canonicalise(rpoly, rden, len);
fmpz_clear(t);
}
void fmpq_poly_set_ui(fmpq_poly_t poly, ulong x)
{
fmpq_poly_fit_length(poly, 1);
fmpz_set_ui(poly->coeffs, x);
fmpz_one(poly->den);
_fmpq_poly_set_length(poly, 1);
_fmpq_poly_normalise(poly);
}
void
fmpz_mat_randntrulike(fmpz_mat_t mat, flint_rand_t state, mp_bitcnt_t bits, ulong q)
{
long r, c, d, i, j, k;
fmpz *h;
r = mat->r;
c = mat->c;
d = r / 2;
if ((c != r) || (c != 2 * d))
{
printf
("Exception: fmpz_mat_randntrulike called on an ill-formed matrix\n");
abort();
}
h = _fmpz_vec_init(d);
for (i = 0; i < d; i++)
fmpz_randbits(h + i, state, bits);
for (i = 0; i < d; i++)
{
for (j = 0; j < i; j++)
fmpz_zero(mat->rows[i] + j);
fmpz_one(mat->rows[i] + i);
for (j = i + 1; j < d; j++)
fmpz_zero(mat->rows[i] + j);
}
for (i = d; i < r; i++)
for (j = 0; j < d; j++)
fmpz_zero(mat->rows[i] + j);
for (i = d; i < r; i++)
{
for (j = d; j < i; j++)
fmpz_zero(mat->rows[i] + j);
fmpz_set_ui(mat->rows[i] + i, q);
for (j = i + 1; j < c; j++)
fmpz_zero(mat->rows[i] + j);
}
for (i = 0; i < d; i++)
{
for (j = d; j < c; j++)
{
k = j + i;
while (k >= d)
k -= d;
fmpz_set(mat->rows[i] + j, h + k);
}
}
_fmpz_vec_clear(h, d);
}
void
_fmpq_poly_invsqrt_series(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, long n)
{
long m;
fmpz * t, * u;
fmpz_t tden, uden;
if (n == 1)
{
fmpz_one(rpoly);
fmpz_one(rden);
return;
}
m = (n + 1) / 2;
_fmpq_poly_invsqrt_series(rpoly, rden, poly, den, m);
fmpz_init(tden);
fmpz_init(uden);
t = _fmpz_vec_init(n);
u = _fmpz_vec_init(n);
_fmpz_vec_zero(rpoly + m, n - m);
_fmpq_poly_mul(t, tden, rpoly, rden, m, rpoly, rden, m);
if (2*m - 1 < n)
fmpz_zero(t + n - 1);
_fmpq_poly_mullow(u, uden, t, tden, n, rpoly, rden, n, n);
_fmpq_poly_mullow(t, tden, u, uden, n, poly, den, n, n);
_fmpz_vec_neg(t + m, t + m, n - m);
_fmpz_vec_zero(t, m);
fmpz_mul_ui(tden, tden, 2UL);
_fmpq_poly_canonicalise(t, tden, n);
_fmpq_poly_add(rpoly, rden, rpoly, rden, m, t, tden, n);
fmpz_clear(tden);
fmpz_clear(uden);
_fmpz_vec_clear(t, n);
_fmpz_vec_clear(u, n);
}
void
fmprb_add_error_2exp_fmpz(fmprb_t x, const fmpz_t err)
{
fmpr_t t;
fmpr_init(t);
fmpz_one(fmpr_manref(t));
fmpz_set(fmpr_expref(t), err);
fmprb_add_error_fmpr(x, t);
fmpr_clear(t);
}
void renf_elem_class::assign(ulong value) noexcept
{
if (nf == nullptr)
{
fmpz_one(fmpq_denref(b));
fmpz_set_ui(fmpq_numref(b), value);
}
else
renf_elem_set_ui(a, value, nf->renf_t());
}
void renf_elem_class::assign(const mpz_class & value) noexcept
{
if (nf == nullptr)
{
fmpz_one(fmpq_denref(b));
fmpz_set_mpz(fmpq_numref(b), value.__get_mp());
}
else
renf_elem_set_mpz(a, value.get_mpz_t(), nf->renf_t());
}
int
main(void)
{
int iter;
FLINT_TEST_INIT(state);
flint_printf("sgn_eval_at_half....");
fflush(stdout);
/* Check aliasing */
for (iter = 0; iter < 1000 * flint_test_multiplier(); iter++)
{
fmpz_t a;
fmpz_poly_t f, g;
long i, d;
int s1, s2;
fmpz_init(a);
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(f, state, n_randint(state, 100), 200);
s1 = fmpz_poly_sgn_eval_at_half(f);
fmpz_poly_set(g, f);
d = fmpz_poly_degree(g);
for (i = 0; i <= d; i++)
{
fmpz_mul_2exp(fmpz_poly_get_coeff_ptr(g, i),
fmpz_poly_get_coeff_ptr(g, i), d - i);
}
fmpz_one(a);
fmpz_poly_evaluate_fmpz(a, g, a);
s2 = fmpz_sgn(a);
if (s1 != s2)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f); printf("\n\n");
printf("s1 = %d, s2 = %d\n\n", s1, s2);
abort();
}
fmpz_clear(a);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
fmpz_mat_det_divisor(fmpz_t d, const fmpz_mat_t A)
{
fmpz_mat_t X, B;
fmpz_t t, u, v, mod;
long i, n;
int success;
n = A->r;
fmpz_mat_init(B, n, 1);
fmpz_mat_init(X, n, 1);
fmpz_init(t);
fmpz_init(u);
fmpz_init(v);
fmpz_init(mod);
/* Create a "random" vector */
for (i = 0; i < n; i++)
{
fmpz_set_si(fmpz_mat_entry(B, i, 0), 2*(i % 2) - 1);
}
success = fmpz_mat_solve_dixon(X, mod, A, B);
if (success)
{
fmpz_one(d);
for (i = 0; i < n; i++)
{
fmpz_mul(t, d, fmpz_mat_entry(X, i, 0));
fmpz_fdiv_qr(u, t, t, mod);
if (!_fmpq_reconstruct_fmpz(u, v, t, mod))
{
printf("Exception: fmpz_mat_det_divisor: "
"rational reconstruction failed!\n");
abort();
}
fmpz_mul(d, v, d);
}
}
else
{
fmpz_zero(d);
}
fmpz_mat_clear(B);
fmpz_mat_clear(X);
fmpz_clear(t);
fmpz_clear(u);
fmpz_clear(v);
fmpz_clear(mod);
}
void
_fmpz_vec_lcm(fmpz_t res, const fmpz * vec, long len)
{
long i;
fmpz_one(res);
for (i = 0; i < len && !fmpz_is_zero(res); i++)
fmpz_lcm(res, res, vec + i);
fmpz_abs(res, res);
}
void fmpq_mat_set_fmpz_mat(fmpq_mat_t dest, const fmpz_mat_t src)
{
slong i, j;
for (i = 0; i < src->r; i++)
{
for (j = 0; j < src->c; j++)
{
fmpz_set(fmpq_mat_entry_num(dest, i, j), fmpz_mat_entry(src, i, j));
fmpz_one(fmpq_mat_entry_den(dest, i, j));
}
}
}
void _qadic_exp_balanced(fmpz *rop, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N, const fmpz_t pN)
{
const slong d = j[lena - 1];
fmpz_t pw;
fmpz *r, *s, *t;
slong i, w;
r = _fmpz_vec_init(d);
s = _fmpz_vec_init(2*d - 1);
t = _fmpz_vec_init(d);
fmpz_init(pw);
fmpz_pow_ui(pw, p, v);
_fmpz_vec_scalar_mul_fmpz(t, x, len, pw);
_fmpz_vec_scalar_mod_fmpz(t, t, len, pN);
_fmpz_vec_zero(t + len, d - len);
fmpz_set(pw, p);
fmpz_one(rop + 0);
_fmpz_vec_zero(rop + 1, d - 1);
w = 1;
while (!_fmpz_vec_is_zero(t, d))
{
fmpz_mul(pw, pw, pw);
for (i = 0; i < d; i++)
{
fmpz_fdiv_r(r + i, t + i, pw);
fmpz_sub(t + i, t + i, r + i);
}
if (!_fmpz_vec_is_zero(r, d))
{
_qadic_exp_bsplit(r, r, w, d, a, j, lena, p, N);
_fmpz_poly_mul(s, rop, d, r, d);
_fmpz_poly_reduce(s, 2*d - 1, a, j, lena);
_fmpz_vec_scalar_mod_fmpz(rop, s, d, pN);
}
w *= 2;
}
_fmpz_vec_clear(r, d);
_fmpz_vec_clear(s, 2*d - 1);
_fmpz_vec_clear(t, d);
fmpz_clear(pw);
}
