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_bsplit_sum_abpq(fmpz_t P, fmpz_t Q, fmpz_t B, fmpz_t T,
const fmpq * ab, const fmpq * pq, long n1, long n2)
{
if (n2 - n1 <= 0)
{
fmpz_zero(P);
fmpz_one(Q);
}
else if (n2 - n1 == 1)
{
fmpz_set(P, fmpq_numref(pq + n1));
fmpz_set(Q, fmpq_denref(pq + n1));
fmpz_set(B, fmpq_denref(ab + n1));
fmpz_mul(T, P, fmpq_numref(ab + n1));
}
else
{
long m = (n1 + n2) / 2;
fmpz_t P2, Q2, B2, T2;
fmpz_init(P2);
fmpz_init(Q2);
fmpz_init(B2);
fmpz_init(T2);
_fmpq_bsplit_sum_abpq(P, Q, B, T, ab, pq, n1, m);
_fmpq_bsplit_sum_abpq(P2, Q2, B2, T2, ab, pq, m, n2);
if (!fmpz_is_one(B2))
fmpz_mul(T, T, B2);
fmpz_mul(T, T, Q2);
if (!fmpz_is_one(B))
fmpz_mul(T2, T2, B);
fmpz_mul(T2, T2, P);
fmpz_add(T, T, T2);
fmpz_mul(P, P, P2);
fmpz_mul(Q, Q, Q2);
fmpz_mul(B, B, B2);
fmpz_clear(P2);
fmpz_clear(Q2);
fmpz_clear(B2);
fmpz_clear(T2);
}
}
void fmpz_poly_q_scalar_mul_si(fmpz_poly_q_t rop, const fmpz_poly_q_t op, long x)
{
fmpz_t cont, fx, gcd;
if (fmpz_poly_q_is_zero(op) || (x == 0))
{
fmpz_poly_q_zero(rop);
return;
}
if (x == 1)
{
fmpz_poly_q_set(rop, op);
return;
}
fmpz_init(cont);
fmpz_poly_content(cont, op->den);
if (fmpz_is_one(cont))
{
fmpz_poly_scalar_mul_si(rop->num, op->num, x);
fmpz_poly_set(rop->den, op->den);
fmpz_clear(cont);
return;
}
fmpz_init(fx);
fmpz_init(gcd);
fmpz_set_si(fx, x);
fmpz_gcd(gcd, cont, fx);
if (fmpz_is_one(gcd))
{
fmpz_poly_scalar_mul_si(rop->num, op->num, x);
fmpz_poly_set(rop->den, op->den);
}
else
{
fmpz_divexact(fx, fx, gcd);
fmpz_poly_scalar_mul_fmpz(rop->num, op->num, fx);
fmpz_poly_scalar_divexact_fmpz(rop->den, op->den, gcd);
}
fmpz_clear(cont);
fmpz_clear(fx);
fmpz_clear(gcd);
}
bool renf_elem_class::is_integer() const noexcept
{
if (nf == nullptr)
return fmpz_is_one(fmpq_denref(b));
else
return renf_elem_is_integer(a, nf->renf_t());
}
/* Extremely close to the branch point at -1/e, use the series expansion directly. */
int
acb_lambertw_try_near_branch_point(acb_t res, const acb_t z,
const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
if (fmpz_is_zero(k) || (fmpz_is_one(k) && arb_is_negative(acb_imagref(z)))
|| (fmpz_equal_si(k, -1) && arb_is_nonnegative(acb_imagref(z))))
{
if (acb_contains_zero(ez1) ||
(arf_cmpabs_2exp_si(arb_midref(acb_realref(ez1)), -prec / 4.5 - 6) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(ez1)), -prec / 4.5 - 6) < 0))
{
acb_t t;
acb_init(t);
acb_mul_2exp_si(t, ez1, 1);
acb_sqrt(t, t, prec);
if (!fmpz_is_zero(k))
acb_neg(t, t);
acb_lambertw_branchpoint_series(res, t, 1, prec);
acb_clear(t);
return 1;
}
}
return 0;
}
void
arb_rising_fmpq_ui(arb_t y, const fmpq_t x, ulong n, long prec)
{
if (n == 0)
{
arb_one(y);
}
else if (n == 1)
{
arb_set_fmpq(y, x, prec);
}
else
{
long wp;
wp = ARF_PREC_ADD(prec, FLINT_BIT_COUNT(n));
bsplit(y, fmpq_numref(x), fmpq_denref(x), 0, n, wp);
if (fmpz_is_one(fmpq_denref(x)))
{
arb_set_round(y, y, prec);
}
else
{
arb_t t;
arb_init(t);
arb_set_fmpz(t, fmpq_denref(x));
arb_pow_ui(t, t, n, wp);
arb_div(y, y, t, prec);
arb_clear(t);
}
}
}
void
_fmpq_poly_compose_series_horner(fmpz * res, fmpz_t den, const fmpz * poly1,
const fmpz_t den1, long len1, const fmpz * poly2,
const fmpz_t den2, long len2, long n)
{
if (fmpz_is_one(den2))
{
_fmpz_poly_compose_series(res, poly1, len1, poly2, len2, n);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, n);
}
else if (n == 1)
{
fmpz_set(res, poly1);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, 1);
}
else
{
long i = len1 - 1;
long lenr;
fmpz_t tden;
fmpz * t = _fmpz_vec_init(n);
fmpz_init(tden);
_fmpz_vec_zero(res, n);
lenr = len2;
_fmpq_poly_scalar_mul_fmpz(res, den, poly2, den2, len2, poly1 + i);
_fmpq_poly_scalar_div_fmpz(res, den, res, den, len2, den1);
i--;
_fmpq_poly_add(res, den, res, den, len2, poly1 + i, den1, 1);
_fmpq_poly_canonicalise(res, den, lenr);
while (i > 0)
{
i--;
if (lenr + len2 - 1 < n)
{
_fmpq_poly_mul(t, tden, res, den, lenr, poly2, den2, len2);
lenr = lenr + len2 - 1;
}
else
{
_fmpq_poly_mullow(t, tden, res, den, lenr,
poly2, den2, len2, n);
lenr = n;
}
_fmpq_poly_canonicalise(t, tden, lenr);
_fmpq_poly_add(res, den, t, tden, lenr, poly1 + i, den1, 1);
}
_fmpq_poly_canonicalise(res, den, n);
_fmpz_vec_clear(t, n);
fmpz_clear(tden);
}
}
slong
fmpq_cfrac_bound(const fmpq_t x)
{
if (fmpz_is_one(fmpq_denref(x)))
return 1;
return fmpz_bits(fmpq_denref(x)) * ONE_OVER_LOG2_PHI + 2;
}
slong
fmpr_rsqrt(fmpr_t y, const fmpr_t x, slong prec, fmpr_rnd_t rnd)
{
slong r;
if (fmpr_is_special(x))
{
if (fmpr_is_zero(x))
fmpr_pos_inf(y);
else if (fmpr_is_pos_inf(x))
fmpr_zero(y);
else
fmpr_nan(y);
return FMPR_RESULT_EXACT;
}
if (fmpr_sgn(x) < 0)
{
fmpr_nan(y);
return FMPR_RESULT_EXACT;
}
/* special case: 4^n */
if (fmpz_is_one(fmpr_manref(x)) && fmpz_is_even(fmpr_expref(x)))
{
r = fmpr_set_round(y, x, prec, rnd);
fmpz_tdiv_q_2exp(fmpr_expref(y), fmpr_expref(y), 1);
fmpz_neg(fmpr_expref(y), fmpr_expref(y));
return r;
}
{
fmpr_t t;
fmpz_t e;
fmpr_init(t);
fmpz_init(e);
fmpz_neg(e, fmpr_expref(x));
if (fmpz_is_odd(e))
fmpz_add_ui(e, e, 1);
fmpr_mul_2exp_fmpz(t, x, e);
CALL_MPFR_FUNC(r, mpfr_rec_sqrt, y, t, prec, rnd);
fmpz_tdiv_q_2exp(e, e, 1);
fmpr_mul_2exp_fmpz(y, y, e);
fmpr_clear(t);
fmpz_clear(e);
return r;
}
}
void fq_nmod_pow(fq_nmod_t rop, const fq_nmod_t op, const fmpz_t e, const fq_nmod_ctx_t ctx)
{
if (fmpz_sgn(e) < 0)
{
flint_printf("Exception (fq_nmod_pow). e < 0.\n");
abort();
}
if (fmpz_is_zero(e))
{
fq_nmod_one(rop, ctx);
}
else if (fq_nmod_is_zero(op, ctx))
{
fq_nmod_zero(rop, ctx);
}
else if (fmpz_is_one(e))
{
fq_nmod_set(rop, op, ctx);
}
else
{
const slong d = fq_nmod_ctx_degree(ctx);
mp_limb_t *t;
if (rop == op)
{
t = _nmod_vec_init(2 * d - 1);
}
else
{
nmod_poly_fit_length(rop, 2 * d - 1);
t = rop->coeffs;
}
_fq_nmod_pow(t, op->coeffs, op->length, e, ctx);
if (rop == op)
{
_nmod_vec_clear(rop->coeffs);
rop->coeffs = t;
rop->alloc = 2 * d - 1;
rop->length = d;
}
else
{
_nmod_poly_set_length(rop, d);
}
_nmod_poly_normalise(rop);
}
}
void
_fmpq_mat_get_fmpz_mat_rowwise(fmpz_mat_struct ** num, fmpz * den,
const fmpq_mat_struct ** mat, slong n)
{
fmpz_t t, lcm;
slong i, j, k;
if (fmpq_mat_is_empty(mat[0]))
return;
fmpz_init(t);
fmpz_init(lcm);
for (i = 0; i < mat[0]->r; i++)
{
/* Compute common denominator of row */
fmpz_set(lcm, fmpq_mat_entry_den(mat[0], i, 0));
for (k = 0; k < n; k++)
for (j = (k == 0); j < mat[k]->c; j++)
fmpz_lcm(lcm, lcm, fmpq_mat_entry_den(mat[k], i, j));
if (den != NULL)
fmpz_set(den + i, lcm);
for (k = 0; k < n; k++)
{
/* Rescale numerators in row */
if (fmpz_is_one(lcm))
{
for (j = 0; j < mat[k]->c; j++)
fmpz_set(fmpz_mat_entry(num[k], i, j),
fmpq_mat_entry_num(mat[k], i, j));
}
else
{
for (j = 0; j < mat[k]->c; j++)
{
fmpz_divexact(t, lcm, fmpq_mat_entry_den(mat[k], i, j));
fmpz_mul(fmpz_mat_entry(num[k], i, j),
fmpq_mat_entry_num(mat[k], i, j), t);
}
}
}
}
fmpz_clear(t);
fmpz_clear(lcm);
}
/* assumes no aliasing */
slong
acb_lambertw_initial(acb_t res, const acb_t z, const acb_t ez1, const fmpz_t k, slong prec)
{
/* Handle z very close to 0 on the principal branch. */
if (fmpz_is_zero(k) &&
(arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -20) <= 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -20) <= 0))
{
acb_set(res, z);
acb_submul(res, res, res, prec);
return 40; /* could be tightened... */
}
/* For moderate input not close to the branch point, compute a double
approximation as the initial value. */
if (fmpz_is_zero(k) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 400) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 400) < 0 &&
(arf_cmp_d(arb_midref(acb_realref(z)), -0.37) < 0 ||
arf_cmp_d(arb_midref(acb_realref(z)), -0.36) > 0 ||
arf_cmpabs_d(arb_midref(acb_imagref(z)), 0.01) > 0))
{
acb_lambertw_principal_d(res, z);
return 48;
}
/* Check if we are close to the branch point at -1/e. */
if ((fmpz_is_zero(k) || (fmpz_is_one(k) && arb_is_negative(acb_imagref(z)))
|| (fmpz_equal_si(k, -1) && arb_is_nonnegative(acb_imagref(z))))
&& ((arf_cmpabs_2exp_si(arb_midref(acb_realref(ez1)), -2) <= 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(ez1)), -2) <= 0)))
{
acb_t t;
acb_init(t);
acb_mul_2exp_si(t, ez1, 1);
mag_zero(arb_radref(acb_realref(t)));
mag_zero(arb_radref(acb_imagref(t)));
acb_mul_ui(t, t, 3, prec);
acb_sqrt(t, t, prec);
if (!fmpz_is_zero(k))
acb_neg(t, t);
acb_lambertw_branchpoint_series(res, t, 0, prec);
acb_clear(t);
return 1; /* todo: estimate */
}
acb_lambertw_initial_asymp(res, z, k, prec);
return 1; /* todo: estimate */
}
void _fmpz_mod_poly_divrem_f(fmpz_t f, fmpz *Q, fmpz *R,
const fmpz *A, slong lenA,
const fmpz *B, slong lenB, const fmpz_t p)
{
fmpz_t invB;
fmpz_init(invB);
fmpz_gcdinv(f, invB, B + lenB - 1, p);
if (fmpz_is_one(f))
{
_fmpz_mod_poly_divrem(Q, R, A, lenA, B, lenB, invB, p);
}
fmpz_clear(invB);
}
void
fmpq_mat_set_fmpz_mat_div_fmpz(fmpq_mat_t X, const fmpz_mat_t Xnum,
const fmpz_t den)
{
slong i, j;
if (fmpz_is_one(den))
{
fmpq_mat_set_fmpz_mat(X, Xnum);
}
else if (*den == WORD(-1))
{
fmpz_t t;
fmpz_init(t);
fmpz_set(t, den);
for (i = 0; i < Xnum->r; i++)
{
for (j = 0; j < Xnum->c; j++)
{
fmpz_neg(fmpq_mat_entry_num(X, i, j),
fmpz_mat_entry(Xnum, i, j));
fmpz_one(fmpq_mat_entry_den(X, i, j));
}
}
fmpz_clear(t);
}
else
{
for (i = 0; i < Xnum->r; i++)
{
for (j = 0; j < Xnum->c; j++)
{
fmpz_set(fmpq_mat_entry_num(X, i, j),
fmpz_mat_entry(Xnum, i, j));
fmpz_set(fmpq_mat_entry_den(X, i, j), den);
fmpq_canonicalise(fmpq_mat_entry(X, i, j));
}
}
}
}
void
arb_pow_fmpq(arb_t y, const arb_t x, const fmpq_t a, long prec)
{
if (fmpz_is_one(fmpq_denref(a)))
{
arb_pow_fmpz(y, x, fmpq_numref(a), prec);
}
else if (fmpz_cmp_ui(fmpq_denref(a), 36) <= 0)
{
arb_root(y, x, *fmpq_denref(a), prec);
arb_pow_fmpz(y, y, fmpq_numref(a), prec);
}
else
{
long wp;
wp = prec + 10;
arb_log(y, x, wp);
arb_mul_fmpz(y, y, fmpq_numref(a), wp);
arb_div_fmpz(y, y, fmpq_denref(a), wp);
arb_exp(y, y, prec);
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("revert_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_revert_series(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
printf("FAIL (aliasing):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g, h;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 10);
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
printf("FAIL (comparison):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_poly_print(h), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("div_basecase....");
fflush(stdout);
flint_randinit(state);
/* Compare to divrem_basecase */
for (i = 0; i < 5000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, q, q2, r2;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(q, p);
fmpz_mod_poly_init(q2, p);
fmpz_mod_poly_init(r2, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1);
{
fmpz_t d;
fmpz *leadB = fmpz_mod_poly_lead(b);
fmpz_init(d);
fmpz_gcd(d, p, leadB);
while (!fmpz_is_one(d))
{
fmpz_divexact(leadB, leadB, d);
fmpz_gcd(d, p, leadB);
}
fmpz_clear(d);
}
fmpz_mod_poly_div_basecase(q, a, b);
fmpz_mod_poly_divrem_basecase(q2, r2, a, b);
result = (fmpz_mod_poly_equal(q, q2));
if (!result)
{
printf("FAIL:\n");
printf("p = "), fmpz_print(p), printf("\n\n");
printf("a = "), fmpz_mod_poly_print(a), printf("\n\n");
printf("b = "), fmpz_mod_poly_print(b), printf("\n\n");
printf("q = "), fmpz_mod_poly_print(q), printf("\n\n");
printf("q2 = "), fmpz_mod_poly_print(q2), printf("\n\n");
printf("r2 = "), fmpz_mod_poly_print(r2), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(q);
fmpz_mod_poly_clear(q2);
fmpz_mod_poly_clear(r2);
fmpz_clear(p);
}
/* Alias a and q */
for (i = 0; i < 500; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, q;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(q, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1);
{
fmpz_t d;
fmpz *leadB = fmpz_mod_poly_lead(b);
fmpz_init(d);
fmpz_gcd(d, p, leadB);
while (!fmpz_is_one(d))
{
fmpz_divexact(leadB, leadB, d);
fmpz_gcd(d, p, leadB);
}
fmpz_clear(d);
}
fmpz_mod_poly_div_basecase(q, a, b);
fmpz_mod_poly_div_basecase(a, a, b);
result = (fmpz_mod_poly_equal(q, a));
if (!result)
{
printf("FAIL:\n");
printf("p = "), fmpz_print(p), printf("\n\n");
printf("a = "), fmpz_mod_poly_print(a), printf("\n\n");
printf("b = "), fmpz_mod_poly_print(b), printf("\n\n");
printf("q = "), fmpz_mod_poly_print(q), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(q);
fmpz_clear(p);
}
/* Alias b and q */
for (i = 0; i < 500; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, q;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(q, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1);
{
fmpz_t d;
fmpz *leadB = fmpz_mod_poly_lead(b);
fmpz_init(d);
fmpz_gcd(d, p, leadB);
while (!fmpz_is_one(d))
{
fmpz_divexact(leadB, leadB, d);
fmpz_gcd(d, p, leadB);
}
fmpz_clear(d);
}
fmpz_mod_poly_div_basecase(q, a, b);
fmpz_mod_poly_div_basecase(b, a, b);
result = (fmpz_mod_poly_equal(q, b));
if (!result)
{
printf("FAIL:\n");
printf("p = "), fmpz_print(p), printf("\n\n");
printf("a = "), fmpz_mod_poly_print(a), printf("\n\n");
printf("b = "), fmpz_mod_poly_print(b), printf("\n\n");
printf("q = "), fmpz_mod_poly_print(q), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(q);
fmpz_clear(p);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
_fmpq_poly_revert_series_lagrange_fast(fmpz * Qinv, fmpz_t den,
const fmpz * Q, const fmpz_t Qden, slong n)
{
slong i, j, k, m;
fmpz *R, *Rden, *S, *T, *dens, *tmp;
fmpz_t Sden, Tden, t;
if (fmpz_is_one(Qden) && (n > 1) && fmpz_is_pm1(Q + 1))
{
_fmpz_poly_revert_series(Qinv, Q, n);
fmpz_one(den);
return;
}
if (n <= 2)
{
fmpz_zero(Qinv);
if (n == 2)
{
fmpz_set(Qinv + 1, Qden);
fmpz_set(den, Q + 1);
_fmpq_poly_canonicalise(Qinv, den, 2);
}
return;
}
m = n_sqrt(n);
fmpz_init(t);
dens = _fmpz_vec_init(n);
R = _fmpz_vec_init((n - 1) * m);
S = _fmpz_vec_init(n - 1);
T = _fmpz_vec_init(n - 1);
Rden = _fmpz_vec_init(m);
fmpz_init(Sden);
fmpz_init(Tden);
fmpz_zero(Qinv);
fmpz_one(dens);
_fmpq_poly_inv_series(Ri(1), Rdeni(1), Q + 1, Qden, n - 1);
_fmpq_poly_canonicalise(Ri(1), Rdeni(1), n - 1);
for (i = 2; i <= m; i++)
{
_fmpq_poly_mullow(Ri(i), Rdeni(i), Ri(i-1), Rdeni(i-1), n - 1,
Ri(1), Rdeni(1), n - 1, n - 1);
_fmpq_poly_canonicalise(Ri(i), Rdeni(i), n - 1);
}
for (i = 1; i < m; i++)
{
fmpz_set(Qinv + i, Ri(i) + i - 1);
fmpz_mul_ui(dens + i, Rdeni(i), i);
}
_fmpz_vec_set(S, Ri(m), n - 1);
fmpz_set(Sden, Rdeni(m));
for (i = m; i < n; i += m)
{
fmpz_set(Qinv + i, S + i - 1);
fmpz_mul_ui(dens + i, Sden, i);
for (j = 1; j < m && i + j < n; j++)
{
fmpz_mul(t, S + 0, Ri(j) + i + j - 1);
for (k = 1; k <= i + j - 1; k++)
fmpz_addmul(t, S + k, Ri(j) + i + j - 1 - k);
fmpz_set(Qinv + i + j, t);
fmpz_mul(dens + i + j, Sden, Rdeni(j));
fmpz_mul_ui(dens + i + j, dens + i + j, i + j);
}
if (i + 1 < n)
{
_fmpq_poly_mullow(T, Tden, S, Sden, n - 1,
Ri(m), Rdeni(m), n - 1, n - 1);
_fmpq_poly_canonicalise(T, Tden, n - 1);
fmpz_swap(Tden, Sden);
tmp = S; S = T; T = tmp;
}
}
_set_vec(Qinv, den, Qinv, dens, n);
_fmpq_poly_canonicalise(Qinv, den, n);
fmpz_clear(t);
_fmpz_vec_clear(dens, n);
_fmpz_vec_clear(R, (n - 1) * m);
_fmpz_vec_clear(S, n - 1);
_fmpz_vec_clear(T, n - 1);
_fmpz_vec_clear(Rden, m);
fmpz_clear(Sden);
fmpz_clear(Tden);
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("divrem_f....");
fflush(stdout);
/* Check q*b + r = a when gcd(lead(B),p) = 1, no aliasing */
for (i = 0; i < 5000; i++)
{
fmpz_t f, p;
fmpz_mod_poly_t a, b, q, r, t;
fmpz_init(f);
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(q, p);
fmpz_mod_poly_init(r, p);
fmpz_mod_poly_init(t, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1);
{
fmpz_t d;
fmpz *leadB = fmpz_mod_poly_lead(b);
fmpz_init(d);
fmpz_gcd(d, p, leadB);
while (!fmpz_is_one(d))
{
fmpz_divexact(leadB, leadB, d);
fmpz_gcd(d, p, leadB);
}
fmpz_clear(d);
}
fmpz_mod_poly_divrem_f(f, q, r, a, b);
fmpz_mod_poly_mul(t, q, b);
fmpz_mod_poly_add(t, t, r);
result = (fmpz_is_one(f) && fmpz_mod_poly_equal(a, t));
if (!result)
{
flint_printf("FAIL (divrem):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n\n");
flint_printf("f = "), fmpz_print(f), flint_printf("\n\n");
flint_printf("a = "), fmpz_mod_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_mod_poly_print(b), flint_printf("\n\n");
flint_printf("q = "), fmpz_mod_poly_print(q), flint_printf("\n\n");
flint_printf("r = "), fmpz_mod_poly_print(r), flint_printf("\n\n");
flint_printf("t = "), fmpz_mod_poly_print(t), flint_printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(q);
fmpz_mod_poly_clear(r);
fmpz_mod_poly_clear(t);
fmpz_clear(f);
fmpz_clear(p);
}
/* Check f | p when gcd(lead(B),p) > 1 */
for (i = 0; i < 5000; i++)
{
fmpz_t f, p, q1, q2;
fmpz_mod_poly_t a, b, q, r, t;
fmpz_init(f);
fmpz_init(p);
fmpz_init(q1);
fmpz_init(q2);
fmpz_randtest_unsigned(q1, state, 2 * FLINT_BITS);
fmpz_randtest_unsigned(q2, state, 2 * FLINT_BITS);
fmpz_add_ui(q1, q1, 2);
fmpz_add_ui(q2, q2, 2);
fmpz_mul(p, q1, q2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(q, p);
fmpz_mod_poly_init(r, p);
fmpz_mod_poly_init(t, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1);
{
fmpz_t d;
fmpz *leadB = fmpz_mod_poly_lead(b);
fmpz_init(d);
fmpz_gcd(d, p, leadB);
if (fmpz_is_one(d))
fmpz_set(leadB, q1);
fmpz_clear(d);
}
fmpz_mod_poly_divrem_f(f, q, r, a, b);
fmpz_mod_poly_mul(t, q, b);
fmpz_mod_poly_add(t, t, r);
result = (fmpz_cmp_ui(f, 1) > 0 && fmpz_cmp(f, p) < 0 && fmpz_divisible(p, f));
if (!result)
{
flint_printf("FAIL (factor):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n\n");
flint_printf("f = "), fmpz_print(f), flint_printf("\n\n");
flint_printf("q1 = "), fmpz_print(q1), flint_printf("\n\n");
flint_printf("q2 = "), fmpz_print(q2), flint_printf("\n\n");
flint_printf("a = "), fmpz_mod_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_mod_poly_print(b), flint_printf("\n\n");
flint_printf("q = "), fmpz_mod_poly_print(q), flint_printf("\n\n");
flint_printf("r = "), fmpz_mod_poly_print(r), flint_printf("\n\n");
flint_printf("t = "), fmpz_mod_poly_print(t), flint_printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(q);
fmpz_mod_poly_clear(r);
fmpz_mod_poly_clear(t);
fmpz_clear(f);
fmpz_clear(p);
fmpz_clear(q1);
fmpz_clear(q2);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void fmpz_mod_poly_divrem_f(fmpz_t f, fmpz_mod_poly_t Q, fmpz_mod_poly_t R,
const fmpz_mod_poly_t A, const fmpz_mod_poly_t B)
{
const slong lenA = A->length;
const slong lenB = B->length;
const slong lenQ = lenA - lenB + 1;
fmpz *q, *r;
fmpz_t invB;
fmpz_init(invB);
fmpz_gcdinv(f, invB, fmpz_poly_lead(B), &(B->p));
if (!fmpz_is_one(f))
{
fmpz_clear(invB);
return;
}
if (lenA < lenB)
{
fmpz_mod_poly_set(R, A);
fmpz_mod_poly_zero(Q);
fmpz_clear(invB);
return;
}
if (Q == A || Q == B)
{
q = _fmpz_vec_init(lenQ);
}
else
{
fmpz_mod_poly_fit_length(Q, lenQ);
q = Q->coeffs;
}
if (R == A || R == B)
{
r = _fmpz_vec_init(lenA);
}
else
{
fmpz_mod_poly_fit_length(R, lenA);
r = R->coeffs;
}
_fmpz_mod_poly_divrem_divconquer(q, r, A->coeffs, lenA,
B->coeffs, lenB, invB, &(B->p));
if (Q == A || Q == B)
{
_fmpz_vec_clear(Q->coeffs, Q->alloc);
Q->coeffs = q;
Q->alloc = lenQ;
Q->length = lenQ;
}
else
{
_fmpz_mod_poly_set_length(Q, lenQ);
}
if (R == A || R == B)
{
_fmpz_vec_clear(R->coeffs, R->alloc);
R->coeffs = r;
R->alloc = lenA;
R->length = lenA;
}
_fmpz_mod_poly_set_length(R, lenB - 1);
_fmpz_mod_poly_normalise(R);
fmpz_clear(invB);
}
void
_fmpq_poly_revert_series_lagrange(fmpz * Qinv, fmpz_t den,
const fmpz * Q, const fmpz_t Qden, long n)
{
long i;
fmpz *R, *S, *T, *dens, *tmp;
fmpz_t Rden, Sden, Tden;
if (fmpz_is_one(Qden) && (n > 1) && fmpz_is_pm1(Q + 1))
{
_fmpz_poly_revert_series(Qinv, Q, n);
fmpz_one(den);
}
else if (n <= 2)
{
fmpz_zero(Qinv);
if (n == 2)
{
fmpz_set(Qinv + 1, Qden);
fmpz_set(den, Q + 1);
_fmpq_poly_canonicalise(Qinv, den, 2);
}
}
else
{
dens = _fmpz_vec_init(n);
R = _fmpz_vec_init(n - 1);
S = _fmpz_vec_init(n - 1);
T = _fmpz_vec_init(n - 1);
fmpz_init(Rden);
fmpz_init(Sden);
fmpz_init(Tden);
fmpz_zero(Qinv);
fmpz_one(dens);
fmpz_set(Qinv + 1, Qden);
fmpz_set(dens + 1, Q + 1);
_fmpq_poly_inv_series(R, Rden, Q + 1, Qden, n - 1);
_fmpq_poly_canonicalise(R, Rden, n - 1);
_fmpz_vec_set(S, R, n - 1);
fmpz_set(Sden, Rden);
for (i = 2; i < n; i++)
{
_fmpq_poly_mullow(T, Tden, S, Sden, n - 1, R, Rden, n - 1, n - 1);
_fmpq_poly_canonicalise(T, Tden, n - 1);
fmpz_set(Qinv + i, T + i - 1);
fmpz_mul_ui(dens + i, Tden, i);
tmp = S; S = T; T = tmp;
fmpz_swap(Sden, Tden);
}
_set_vec(Qinv, den, Qinv, dens, n);
_fmpq_poly_canonicalise(Qinv, den, n);
_fmpz_vec_clear(R, n - 1);
_fmpz_vec_clear(S, n - 1);
_fmpz_vec_clear(T, n - 1);
_fmpz_vec_clear(dens, n);
fmpz_clear(Rden);
fmpz_clear(Sden);
fmpz_clear(Tden);
}
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("revert_series_lagrange_fast....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_revert_series_lagrange_fast(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
flint_printf("FAIL (comparison):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("remove....");
fflush(stdout);
/* Compare with MPIR, random input */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
mpz_t d, e, f, g;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
x = fmpz_remove(c, a, b);
y = mpz_remove(f, d, e);
fmpz_get_mpz(g, c);
result = ((x == y) && (mpz_cmp(f, g) == 0));
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Compare with MPIR, random input but ensure that factors exist */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, pow;
mpz_t d, e, f, g;
slong x, y;
ulong n;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(pow);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
n = n_randint(state, 10);
fmpz_pow_ui(pow, b, n);
fmpz_mul(a, a, pow);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
x = fmpz_remove(c, a, b);
y = mpz_remove(f, d, e);
fmpz_get_mpz(g, c);
result = ((x == y) && (x >= n) && (mpz_cmp(f, g) == 0));
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(pow);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Check aliasing of a and b */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
slong x;
fmpz_init(a);
fmpz_init(c);
do {
fmpz_randtest_not_zero(a, state, 200);
fmpz_abs(a, a);
} while (fmpz_is_one(a));
x = fmpz_remove(c, a, a);
result = ((x == 1) && (fmpz_cmp_ui(c, 1) == 0));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
x = fmpz_remove(c, a, b);
y = fmpz_remove(a, a, b);
result = ((x == y) && fmpz_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(b), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
x = fmpz_remove(c, a, b);
y = fmpz_remove(b, a, b);
result = ((x == y) && fmpz_equal(b, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(b), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("gamma_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t r, s;
fmpq_t q;
slong accuracy, prec, pp, qq;
prec = 2 + n_randint(state, 1 << n_randint(state, 12));
prec += 20;
arb_init(r);
arb_init(s);
fmpq_init(q);
pp = -100 + n_randint(state, 10000);
qq = 1 + n_randint(state, 20);
fmpq_set_si(q, pp, qq);
arb_gamma_fmpq(r, q, prec);
arb_set_fmpq(s, q, prec);
arb_gamma(s, s, prec);
if (!arb_overlaps(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); arb_printd(s, prec / 3.33); flint_printf("\n\n");
abort();
}
if (!(fmpz_is_one(fmpq_denref(q)) && fmpz_sgn(fmpq_numref(q)) <= 0)
&& FLINT_ABS(pp / qq) < 10)
{
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 6)
{
flint_printf("FAIL: poor accuracy\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
abort();
}
}
arb_clear(r);
arb_clear(s);
fmpq_clear(q);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("resultant_div....");
fflush(stdout);
for (i = 0; i < 50; i++)
{
fmpq_poly_t f, g, h, p;
fmpq_t x, y, z, zz;
fmpz_t den;
slong nbits;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(p);
fmpq_poly_init(h);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_init(zz);
fmpz_init(den);
fmpq_poly_randtest(f, state, n_randint(state, 50), 100);
fmpq_poly_randtest(g, state, n_randint(state, 50), 100);
fmpq_poly_randtest(h, state, n_randint(state, 50), 100);
fmpz_set(den, fmpq_poly_denref(f));
fmpq_poly_scalar_mul_fmpz(f, f, den);
fmpz_set(den, fmpq_poly_denref(g));
fmpq_poly_scalar_mul_fmpz(g, g, den);
fmpz_set(den, fmpq_poly_denref(h));
fmpq_poly_scalar_mul_fmpz(h, h, den);
fmpq_poly_mul(p, f, g);
fmpq_poly_resultant(x, f, h);
if (!fmpz_is_one(fmpq_denref(x)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("f = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_resultant(y, g, h);
if (!fmpz_is_one(fmpq_denref(y)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("h = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("z = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_resultant(z, p, h);
if (!fmpz_is_one(fmpq_denref(z)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("p = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
if (fmpq_is_zero(z))
{
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
fmpq_poly_clear(p);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_clear(zz);
fmpz_clear(den);
continue;
}
nbits = (slong)fmpz_bits(fmpq_numref(y)) + 1;
fmpq_poly_resultant_div(z, p, h, fmpq_numref(x), nbits);
fmpq_poly_resultant(zz, p, h);
result = fmpq_equal(z, y);
if (!result)
{
flint_printf("FAIL (res(p, g)/div == res(p, g)/div:\n");
flint_printf("p = "), fmpq_poly_print_pretty(p, "x"), flint_printf("\n\n");
flint_printf("h = "), fmpq_poly_print_pretty(h, "x"), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpq_print(zz), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpq_print(x), flint_printf(" * "), fmpq_print(y), flint_printf("\n\n");
flint_printf("supplied divisor = "), fmpq_print(x), flint_printf("\n\n");
flint_printf("nbits = %wu\n\n", nbits);
flint_printf("divisor found = "), fmpq_print(z), flint_printf("\n\n");
flint_printf("correct result = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
fmpq_poly_clear(p);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_clear(zz);
fmpz_clear(den);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void _fq_nmod_pow(mp_limb_t *rop, const mp_limb_t *op, slong len, const fmpz_t e,
const fq_nmod_ctx_t ctx)
{
const slong d = fq_nmod_ctx_degree(ctx);
if (fmpz_is_zero(e))
{
rop[0] = WORD(1);
_nmod_vec_zero(rop + 1, 2 * d - 1 - 1);
}
else if (fmpz_is_one(e))
{
_nmod_vec_set(rop, op, len);
_nmod_vec_zero(rop + len, 2 * d - 1 - len);
}
else
{
ulong bit;
mp_limb_t *v = _nmod_vec_init(2 * d - 1);
mp_limb_t *R, *S, *T;
_nmod_vec_zero(v, 2 * d - 1);
_nmod_vec_zero(rop, 2 * d - 1);
/*
Set bits to the bitmask with a 1 one place lower than the msb of e
*/
bit = fmpz_bits(e) - 2;
/*
Trial run without any polynomial arithmetic to determine the parity
of the number of swaps; then set R and S accordingly
*/
{
unsigned int swaps = 0U;
ulong bit2 = bit;
if (fmpz_tstbit(e, bit2))
swaps = ~swaps;
while (bit2--)
if (!fmpz_tstbit(e, bit2))
swaps = ~swaps;
if (swaps == 0U)
{
R = rop;
S = v;
}
else
{
R = v;
S = rop;
}
}
/*
We unroll the first step of the loop, referring to {op, len}
*/
_nmod_poly_mul(R, op, len, op, len, ctx->mod);
_fq_nmod_reduce(R, 2 * len - 1, ctx);
if (fmpz_tstbit(e, bit))
{
_nmod_poly_mul(S, R, d, op, len, ctx->mod);
_fq_nmod_reduce(S, d + len - 1, ctx);
T = R;
R = S;
S = T;
}
while (bit--)
{
if (fmpz_tstbit(e, bit))
{
_nmod_poly_mul(S, R, d, R, d, ctx->mod);
_fq_nmod_reduce(S, 2 * d - 1, ctx);
_nmod_poly_mul(R, S, d, op, len, ctx->mod);
_fq_nmod_reduce(R, d + len - 1, ctx);
}
else
{
_nmod_poly_mul(S, R, d, R, d, ctx->mod);
_fq_nmod_reduce(S, 2 * d - 1, ctx);
T = R;
R = S;
S = T;
}
}
_nmod_vec_clear(v);
}
}
void fmpz_multi_CRT_ui(fmpz_t output, unsigned long * residues, fmpz_comb_t comb, fmpz_t ** comb_temp)
{
ulong i, j, k;
ulong n = comb->n;
ulong num;
ulong log_res;
mp_limb_t * ptr;
ulong size;
ulong num_primes = comb->num_primes;
if (num_primes == 1) // the output is less than a single prime, so just output the result
{
unsigned long p = comb->primes[0];
if ((p - residues[0]) < residues[0]) fmpz_set_si(output, (long) (residues[0] - p));
else fmpz_set_ui(output, residues[0]);
return;
}
// first layer of reconstruction
num = (1L<<n);
mp_limb_t temps[3];
mp_limb_t temp2s[3];
for (i = 0, j = 0; i + 2 <= num_primes; i += 2, j++)
{
fmpz_set_ui(temps, residues[i]);
fmpz_set_ui(temp2s, fmpz_mod_ui(temps, comb->primes[i+1]));
fmpz_sub_ui_inplace(temp2s, residues[i + 1]);
temp2s[0] = -temp2s[0];
fmpz_mul(temps, temp2s, comb->res[0][j]);
fmpz_set_ui(temp2s, fmpz_mod_ui(temps, comb->primes[i+1]));
fmpz_mul_ui(temps, temp2s, comb->primes[i]);
fmpz_add_ui(comb_temp[0][j], temps, residues[i]);
}
if (i < num_primes) fmpz_set_ui(comb_temp[0][j], residues[i]);
// compute other layers of reconstruction
fmpz_t temp = (fmpz_t) flint_heap_alloc(2*num + 1);
fmpz_t temp2 = (fmpz_t) flint_heap_alloc(2*num + 1);
num /= 2;
log_res = 1;
while (log_res < n)
{
for (i = 0, j = 0; i < num; i += 2, j++)
{
if (fmpz_is_one(comb->comb[log_res-1][i+1]))
{
if (!fmpz_is_one(comb->comb[log_res-1][i])) fmpz_set(comb_temp[log_res][j], comb_temp[log_res-1][i]);
} else
{
fmpz_mod(temp2, comb_temp[log_res-1][i], comb->comb[log_res-1][i+1]);
fmpz_sub(temp, temp2, comb_temp[log_res-1][i+1]);
temp[0] = -temp[0];
fmpz_mul(temp2, temp, comb->res[log_res][j]);
fmpz_mod(temp, temp2, comb->comb[log_res-1][i+1]);
fmpz_mul(temp2, temp, comb->comb[log_res-1][i]);
fmpz_add(comb_temp[log_res][j], temp2, comb_temp[log_res-1][i]);
}
}
log_res++;
num /= 2;
}
// write out the output
__fmpz_multi_CRT_sign(comb_temp[log_res - 1][0], comb_temp[log_res - 1][0], comb);
fmpz_set(output, comb_temp[log_res - 1][0]);
flint_heap_free(temp2); //temp2
flint_heap_free(temp); //temp
}
void
fmpq_poly_compose_series_horner(fmpq_poly_t res,
const fmpq_poly_t poly1, const fmpq_poly_t poly2, long n)
{
long len1 = poly1->length;
long len2 = poly2->length;
long lenr;
if (len2 != 0 && !fmpz_is_zero(poly2->coeffs))
{
printf("exception: fmpq_poly_compose_series_horner: inner polynomial "
"must have zero constant term\n");
abort();
}
if (len1 == 0 || n == 0)
{
fmpq_poly_zero(res);
return;
}
if (len2 == 0 || len1 == 1)
{
fmpq_poly_fit_length(res, 1);
fmpz_set(res->coeffs, poly1->coeffs);
fmpz_set(res->den, poly1->den);
{
fmpz_t d;
fmpz_init(d);
fmpz_gcd(d, res->coeffs, res->den);
if (!fmpz_is_one(d))
{
fmpz_divexact(res->coeffs, res->coeffs, d);
fmpz_divexact(res->den, res->den, d);
}
fmpz_clear(d);
}
_fmpq_poly_set_length(res, 1);
_fmpq_poly_normalise(res);
return;
}
lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n);
len1 = FLINT_MIN(len1, lenr);
len2 = FLINT_MIN(len2, lenr);
if ((res != poly1) && (res != poly2))
{
fmpq_poly_fit_length(res, lenr);
_fmpq_poly_compose_series_horner(res->coeffs, res->den,
poly1->coeffs, poly1->den, len1,
poly2->coeffs, poly2->den, len2, lenr);
_fmpq_poly_set_length(res, lenr);
_fmpq_poly_normalise(res);
}
else
{
fmpq_poly_t t;
fmpq_poly_init2(t, lenr);
_fmpq_poly_compose_series_horner(t->coeffs, t->den,
poly1->coeffs, poly1->den, len1,
poly2->coeffs, poly2->den, len2, lenr);
_fmpq_poly_set_length(t, lenr);
_fmpq_poly_normalise(t);
fmpq_poly_swap(res, t);
fmpq_poly_clear(t);
}
}
void fmpz_mod(fmpz_t res, const fmpz_t a, const fmpz_t b)
{
long a0 = a[0];
long b0 = b[0];
unsigned long sizea = FLINT_ABS(a0);
unsigned long sizeb = b0;
while ((!a[sizea]) && (sizea)) sizea--;
while ((!b[sizeb]) && (sizeb)) sizeb--;
mp_limb_t mslimb;
fmpz_t temp, temp2;
if (sizeb == 0)
{
printf("Error: division by zero!\n");
abort();
} else if (sizea < sizeb)
{
if ((long) a0 < 0L)
{
temp = (fmpz_t) flint_stack_alloc(sizeb + 2);
fmpz_add(temp, a, b);
fmpz_set(res, temp);
flint_stack_release();
} else fmpz_set(res, a);
return;
} else if ((sizea == sizeb) && (fmpz_cmpabs(a, b) < 0L))
{
if (fmpz_sgn(a) < 0) fmpz_add(res, a, b);
else fmpz_set(res, a);
return;
} else
{
if (fmpz_is_one(b))
{
fmpz_set_ui(res, 0L);
return;
}
temp = (fmpz_t) flint_stack_alloc(sizea - sizeb + 1);
temp2 = (fmpz_t) flint_stack_alloc(sizeb + 2);
mpn_tdiv_qr(temp, temp2+1, 0, a+1, sizea, b+1, sizeb);
temp2[0] = sizeb;
NORM(temp2);
if (a0 < 0L)
{
unsigned long i = 0;
for (; i < sizeb; i++)
{
if (temp2[i+1]) break;
}
if (i < sizeb)
{
fmpz_sub(temp2, b, temp2);
}
fmpz_set(res, temp2);
} else fmpz_set(res, temp2);
flint_stack_release();
flint_stack_release();
}
}
int fmpz_divides(fmpz_t q, const fmpz_t a, const fmpz_t b)
{
long a0 = a[0];
long b0 = b[0];
unsigned long sizea = FLINT_ABS(a0);
unsigned long sizeb = FLINT_ABS(b0);
mp_limb_t mslimb;
fmpz_t temp;
if (sizeb == 0)
{
printf("Error: division by zero!\n");
abort();
} else if (sizea == 0)
{
q[0] = 0;
return 1;
} else if (sizea < sizeb)
{
return 0;
} else if (sizea == sizeb)
{
int cmp = fmpz_cmpabs(a, b);
if (cmp < 0) return 0;
if (cmp == 0)
{
if ((long) (a0 ^ b0) < 0L) q[0] = -1L;
else q[0] = 1L;
q[1] = 1;
return 1;
}
}
if (fmpz_is_one(b))
{
fmpz_set(q, a);
return 1;
}
if (fmpz_is_m1(b))
{
fmpz_neg(q, a);
return 1;
}
temp = (fmpz_t) flint_stack_alloc(sizeb + 2);
mpn_tdiv_qr(q+1, temp+1, 0, a+1, sizea, b+1, sizeb);
temp[0] = sizeb;
NORM(temp);
if (temp[0] != 0)
{
flint_stack_release();
return 0;
}
q[0] = sizea - sizeb + 1;
NORM(q);
if ((long) (a0 ^ b0) < 0L) q[0] = -q[0];
flint_stack_release();
return 1;
}