slong
fmpr_add_naive(fmpr_t z, const fmpr_t x, const fmpr_t y, slong prec, fmpr_rnd_t rnd)
{
slong shift, xsize, ysize;
if (fmpr_is_special(x) || fmpr_is_special(y))
{
return _fmpr_add_special(z, x, y, prec, rnd);
}
shift = _fmpz_sub_small(fmpr_expref(x), fmpr_expref(y));
if (shift == 0)
{
fmpz_add(fmpr_manref(z), fmpr_manref(x), fmpr_manref(y));
fmpz_set(fmpr_expref(z), fmpr_expref(x));
}
else if (shift > 0)
{
ysize = _fmpz_size(fmpr_manref(y)) * FLINT_BITS;
/* x and y do not overlap */
if (shift > ysize && prec != FMPR_PREC_EXACT)
{
/* y does not overlap with result */
if (ysize + prec - (slong) fmpz_bits(fmpr_manref(x)) < shift)
{
return _fmpr_add_eps(z, x, fmpz_sgn(fmpr_manref(y)), prec, rnd);
}
}
fmpz_add_mul2exp(fmpr_manref(z), fmpr_manref(y), fmpr_manref(x), shift);
fmpz_set(fmpr_expref(z), fmpr_expref(y));
}
else
{
shift = -shift;
xsize = _fmpz_size(fmpr_manref(x)) * FLINT_BITS;
/* x and y do not overlap */
if (shift > xsize && prec != FMPR_PREC_EXACT)
{
/* y does not overlap with result */
if (xsize + prec - (slong) fmpz_bits(fmpr_manref(y)) < shift)
{
return _fmpr_add_eps(z, y, fmpz_sgn(fmpr_manref(x)), prec, rnd);
}
}
fmpz_add_mul2exp(fmpr_manref(z), fmpr_manref(x), fmpr_manref(y), shift);
fmpz_set(fmpr_expref(z), fmpr_expref(x));
}
return _fmpr_normalise(fmpr_manref(z), fmpr_expref(z), prec, rnd);
}
void
fmpz_fdiv_q(fmpz_t f, const fmpz_t g, const fmpz_t h)
{
fmpz c1 = *g;
fmpz c2 = *h;
if (fmpz_is_zero(h))
{
printf("Exception: division by zero in fmpz_fdiv_q\n");
abort();
}
if (!COEFF_IS_MPZ(c1)) /* g is small */
{
if (!COEFF_IS_MPZ(c2)) /* h is also small */
{
fmpz q = c1 / c2; /* compute C quotient */
fmpz r = c1 - c2 * q; /* compute remainder */
if (r && (c2 ^ r) < 0L)
--q;
fmpz_set_si(f, q);
}
else /* h is large and g is small */
{
if ((c1 > 0L && fmpz_sgn(h) < 0) || (c1 < 0L && fmpz_sgn(h) > 0)) /* signs are the same */
fmpz_set_si(f, -1L); /* quotient is negative, round down to minus one */
else
fmpz_zero(f);
}
}
else /* g is large */
{
__mpz_struct *mpz_ptr = _fmpz_promote(f);
if (!COEFF_IS_MPZ(c2)) /* h is small */
{
if (c2 > 0) /* h > 0 */
{
mpz_fdiv_q_ui(mpz_ptr, COEFF_TO_PTR(c1), c2);
}
else
{
mpz_cdiv_q_ui(mpz_ptr, COEFF_TO_PTR(c1), -c2);
mpz_neg(mpz_ptr, mpz_ptr);
}
}
else /* both are large */
{
mpz_fdiv_q(mpz_ptr, COEFF_TO_PTR(c1), COEFF_TO_PTR(c2));
}
_fmpz_demote_val(f); /* division by h may result in small value */
}
}
/* quotient of absolute value, rounded up */
static __inline__ void
fmpz_cdiv_abs_q(fmpz_t q, const fmpz_t x, const fmpz_t y)
{
if (fmpz_sgn(x) == fmpz_sgn(y))
{
fmpz_cdiv_q(q, x, y);
}
else
{
fmpz_fdiv_q(q, x, y);
fmpz_neg(q, q);
}
}
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
fmpr_divappr_abs_ubound(fmpr_t z, const fmpr_t x, const fmpr_t y, slong prec)
{
if (fmpr_is_special(x) || fmpr_is_special(y) || fmpz_is_pm1(fmpr_manref(y)))
{
fmpr_div(z, x, y, prec, FMPR_RND_UP);
fmpr_abs(z, z);
}
else
{
fmpz_t t, u;
slong xbits, ybits, tbits, ubits, shift;
xbits = fmpz_bits(fmpr_manref(x));
ybits = fmpz_bits(fmpr_manref(y));
fmpz_init(t);
fmpz_init(u);
ubits = FLINT_MIN(ybits, prec);
tbits = prec + ubits + 1;
/* upper bound for |x|, shifted */
if (xbits <= tbits)
{
fmpz_mul_2exp(t, fmpr_manref(x), tbits - xbits);
fmpz_abs(t, t);
}
else if (fmpz_sgn(fmpr_manref(x)) > 0)
{
fmpz_cdiv_q_2exp(t, fmpr_manref(x), xbits - tbits);
}
else
{
fmpz_fdiv_q_2exp(t, fmpr_manref(x), xbits - tbits);
fmpz_neg(t, t);
}
/* lower bound for |y|, shifted */
if (ybits <= ubits)
fmpz_mul_2exp(u, fmpr_manref(y), ubits - ybits);
else
fmpz_tdiv_q_2exp(u, fmpr_manref(y), ybits - ubits);
fmpz_abs(u, u);
fmpz_cdiv_q(fmpr_manref(z), t, u);
shift = (ubits - ybits) - (tbits - xbits);
fmpz_sub(fmpr_expref(z), fmpr_expref(x), fmpr_expref(y));
if (shift >= 0)
fmpz_add_ui(fmpr_expref(z), fmpr_expref(z), shift);
else
fmpz_sub_ui(fmpr_expref(z), fmpr_expref(z), -shift);
_fmpr_normalise(fmpr_manref(z), fmpr_expref(z), prec, FMPR_RND_UP);
fmpz_clear(t);
fmpz_clear(u);
}
}
void
fmpz_poly_bit_unpack_unsigned(fmpz_poly_t poly, const fmpz_t f,
mp_bitcnt_t bit_size)
{
slong len;
mpz_t tmp;
if (fmpz_sgn(f) < 0)
{
flint_printf("Exception (fmpz_poly_bit_unpack_unsigned). Expected an unsigned value.\n");
abort();
}
if (bit_size == 0 || fmpz_is_zero(f))
{
fmpz_poly_zero(poly);
return;
}
len = (fmpz_bits(f) + bit_size - 1) / bit_size;
mpz_init2(tmp, bit_size*len);
flint_mpn_zero(tmp->_mp_d, tmp->_mp_alloc);
fmpz_get_mpz(tmp, f);
fmpz_poly_fit_length(poly, len);
_fmpz_poly_bit_unpack_unsigned(poly->coeffs, len, tmp->_mp_d, bit_size);
_fmpz_poly_set_length(poly, len);
_fmpz_poly_normalise(poly);
mpz_clear(tmp);
}
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 ARingZZ::syzygy(const ElementType& a, const ElementType& b,
ElementType& x, ElementType& y) const
{
M2_ASSERT(!is_zero(b));
// First check the special cases a = 0, b = 1, -1. Other cases: use gcd.
if (is_zero(a))
{
set_from_long(x, 1);
set_zero(y);
return;
}
if (fmpz_cmp_ui(&b,1) == 0)
{
set_from_long(x, 1);
negate(y, a);
return;
}
if (fmpz_cmp_si(&b,-1) == 0)
{
set_from_long(x, 1);
set(y, a);
return;
}
ElementType g;
init(g);
fmpz_gcd(&g,&a,&b);
divide(y,a,g);
divide(x,b,g);
if (fmpz_sgn(&x) > 0)
negate(y,y);
else
negate(x,x);
clear(g);
}
void fmpz_poly_q_canonicalise(fmpz_poly_q_t rop)
{
fmpz_poly_t gcd;
if (fmpz_poly_is_zero(rop->den))
{
flint_printf("Exception (fmpz_poly_q_canonicalise). Denominator is zero.\n");
abort();
}
if (fmpz_poly_is_one(rop->den))
return;
fmpz_poly_init(gcd);
fmpz_poly_gcd(gcd, rop->num, rop->den);
if (!fmpz_poly_is_unit(gcd))
{
fmpz_poly_div(rop->num, rop->num, gcd);
fmpz_poly_div(rop->den, rop->den, gcd);
}
fmpz_poly_clear(gcd);
if (fmpz_sgn(fmpz_poly_lead(rop->den)) < 0)
{
fmpz_poly_neg(rop->num, rop->num);
fmpz_poly_neg(rop->den, rop->den);
}
}
void fmpz_powm(fmpz_t f, const fmpz_t g, const fmpz_t e, const fmpz_t m)
{
if (fmpz_sgn(m) <= 0)
{
flint_printf("Exception (fmpz_powm). Modulus is less than 1.\n");
abort();
}
else if (!COEFF_IS_MPZ(*e)) /* e is small */
{
fmpz_powm_ui(f, g, *e, m);
}
else /* e is large */
{
if (!COEFF_IS_MPZ(*m)) /* m is small */
{
ulong g1 = fmpz_fdiv_ui(g, *m);
mpz_t g2, m2;
__mpz_struct *mpz_ptr;
flint_mpz_init_set_ui(g2, g1);
flint_mpz_init_set_ui(m2, *m);
mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr, g2, COEFF_TO_PTR(*e), m2);
mpz_clear(g2);
mpz_clear(m2);
_fmpz_demote_val(f);
}
else /* m is large */
{
if (!COEFF_IS_MPZ(*g)) /* g is small */
{
mpz_t g2;
__mpz_struct *mpz_ptr;
flint_mpz_init_set_si(g2, *g);
mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr, g2, COEFF_TO_PTR(*e), COEFF_TO_PTR(*m));
mpz_clear(g2);
_fmpz_demote_val(f);
}
else /* g is large */
{
__mpz_struct *mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr,
COEFF_TO_PTR(*g), COEFF_TO_PTR(*e), COEFF_TO_PTR(*m));
_fmpz_demote_val(f);
}
}
}
}
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_mod_poly_sub(fmpz *res, const fmpz *poly1, long len1,
const fmpz *poly2, long len2, const fmpz_t p)
{
long i, len = FLINT_MAX(len1, len2);
_fmpz_poly_sub(res, poly1, len1, poly2, len2);
for (i = 0; i < len; i++)
{
if (fmpz_sgn(res + i) < 0)
fmpz_add(res + i, res + i, p);
}
}
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);
}
}
int renf_elem_sgn(renf_elem_t a, renf_t nf)
{
slong prec;
slong cond;
if (nf_elem_is_rational(a->elem, nf->nf))
{
if (nf->nf->flag & NF_LINEAR)
return fmpz_sgn(LNF_ELEM_NUMREF(a->elem));
else if (nf->nf->flag & NF_QUADRATIC)
return fmpz_sgn(QNF_ELEM_NUMREF(a->elem));
else if (NF_ELEM(a->elem)->length == 0)
return 0;
else
return fmpz_sgn(NF_ELEM_NUMREF(a->elem));
}
if (!arb_contains_zero(a->emb))
return arf_sgn(arb_midref(a->emb));
renf_elem_relative_condition_number_2exp(&cond, a, nf);
prec = FLINT_MAX(nf->prec, arb_rel_accuracy_bits(nf->emb));
renf_elem_set_evaluation(a, nf, prec + cond);
do
{
if (!arb_contains_zero(a->emb))
return arf_sgn(arb_midref(a->emb));
prec *= 2;
renf_refine_embedding(nf, prec);
renf_elem_set_evaluation(a, nf, prec + cond);
} while(1);
/* we should not get here */
abort();
return -3;
}
void
elem_sub(elem_ptr res, elem_srcptr op1, elem_srcptr op2, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
fmpz_sub(res, op1, op2);
break;
case TYPE_LIMB:
*((mp_ptr) res) = *((mp_srcptr) op1) - *((mp_srcptr) op2);
break;
case TYPE_POLY:
elem_poly_sub(res, op1, op2, ring);
break;
case TYPE_MOD:
{
switch (RING_PARENT(ring)->type)
{
case TYPE_LIMB:
*((mp_ptr) res) = n_submod(*((mp_srcptr) op1), *((mp_srcptr) op2), ring->nmod.n);
break;
case TYPE_FMPZ:
fmpz_sub(res, op1, op2);
if (fmpz_sgn(res) < 0)
fmpz_add(res, res, RING_MODULUS(ring));
break;
default:
NOT_IMPLEMENTED("sub (mod)", ring);
}
}
break;
case TYPE_FRAC:
elem_frac_sub(res, op1, op2, ring);
break;
case TYPE_COMPLEX:
elem_sub(REALPART(res, ring), REALPART(op1, ring), REALPART(op2, ring), ring->parent);
elem_sub(IMAGPART(res, ring), IMAGPART(op1, ring), IMAGPART(op2, ring), ring->parent);
break;
default:
NOT_IMPLEMENTED("sub", ring);
}
}
void
mag_expinv(mag_t res, const mag_t x)
{
if (mag_is_zero(x))
{
mag_one(res);
}
else if (mag_is_inf(x))
{
mag_zero(res);
}
else if (fmpz_sgn(MAG_EXPREF(x)) <= 0)
{
mag_one(res);
}
else if (fmpz_cmp_ui(MAG_EXPREF(x), 2 * MAG_BITS) > 0)
{
fmpz_t t;
fmpz_init(t);
/* If x > 2^60, exp(-x) < 2^(-2^60 / log(2)) */
/* -1/log(2) < -369/256 */
fmpz_set_si(t, -369);
fmpz_mul_2exp(t, t, 2 * MAG_BITS - 8);
mag_one(res);
mag_mul_2exp_fmpz(res, res, t);
fmpz_clear(t);
}
else
{
fmpz_t t;
slong e = MAG_EXP(x);
fmpz_init(t);
fmpz_set_ui(t, MAG_MAN(x));
if (e >= MAG_BITS)
fmpz_mul_2exp(t, t, e - MAG_BITS);
else
fmpz_tdiv_q_2exp(t, t, MAG_BITS - e);
/* upper bound for 1/e */
mag_set_ui_2exp_si(res, 395007543, -30);
mag_pow_fmpz(res, res, t);
fmpz_clear(t);
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("height....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz *a;
fmpz_t h;
long len, bits, bits2;
fmpz_init(h);
len = n_randint(state, 100);
a = _fmpz_vec_init(len);
bits = n_randint(state, 200);
_fmpz_vec_randtest(a, state, len, bits);
bits2 = _fmpz_vec_max_bits(a, len);
_fmpz_vec_height(h, a, len);
result = (fmpz_bits(h) == FLINT_ABS(bits2)) && (fmpz_sgn(h) >= 0);
if (!result)
{
printf("FAIL:\n");
printf("bits = %ld, bits2 = %ld\n", bits, bits2);
printf("Computed height:\n");
fmpz_print(h);
printf("\n");
abort();
}
fmpz_clear(h);
_fmpz_vec_clear(a, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
partitions_fmpz_fmpz(fmpz_t res, const fmpz_t n, int use_doubles)
{
if (fmpz_cmp_ui(n, 2000) < 0)
{
if (fmpz_sgn(n) < 0)
fmpz_zero(res);
else
_partitions_fmpz_ui(res, *n, use_doubles);
}
else
{
partitions_fmpz_fmpz_hrr(res, n, use_doubles);
}
}
void fmpz_ramanujan_tau(fmpz_t res, const fmpz_t n)
{
fmpz_factor_t factors;
if (fmpz_sgn(n) <= 0)
{
fmpz_zero(res);
return;
}
fmpz_factor_init(factors);
fmpz_factor(factors, n);
_fmpz_ramanujan_tau(res, factors);
fmpz_factor_clear(factors);
}
void _fmpz_poly_sqrlow_KS(fmpz * res, const fmpz * poly, long len, long n)
{
int neg;
long bits, limbs, loglen, sign = 0;
mp_limb_t *arr_in, *arr_out;
FMPZ_VEC_NORM(poly, len);
if (len == 0)
{
_fmpz_vec_zero(res, n);
return;
}
neg = (fmpz_sgn(poly + len - 1) > 0) ? 0 : -1;
if (n > 2 * len - 1)
{
_fmpz_vec_zero(res + 2 * len - 1, n - (2 * len - 1));
n = 2 * len - 1;
}
bits = _fmpz_vec_max_bits(poly, len);
if (bits < 0)
{
sign = 1;
bits = - bits;
}
loglen = FLINT_BIT_COUNT(len);
bits = 2 * bits + loglen + sign;
limbs = (bits * len - 1) / FLINT_BITS + 1;
arr_in = flint_calloc(limbs, sizeof(mp_limb_t));
arr_out = flint_malloc((2 * limbs) * sizeof(mp_limb_t));
_fmpz_poly_bit_pack(arr_in, poly, len, bits, neg);
mpn_sqr(arr_out, arr_in, limbs);
if (sign)
_fmpz_poly_bit_unpack(res, n, arr_out, bits, 0);
else
_fmpz_poly_bit_unpack_unsigned(res, n, arr_out, bits);
flint_free(arr_in);
flint_free(arr_out);
}
long
_fmpz_vec_max_bits(const fmpz * vec, long len)
{
long i, bits, max_bits = 0, sign = 1;
for (i = 0; i < len; i++)
{
bits = fmpz_bits(vec + i);
if (bits > max_bits)
max_bits = bits;
if (fmpz_sgn(vec + i) < 0)
sign = -1L;
}
return max_bits * sign;
}
slong
fmpr_mul_fmpz(fmpr_t z, const fmpr_t x, const fmpz_t y, slong prec, fmpr_rnd_t rnd)
{
fmpz xv, yv;
fmpz yexp;
if (fmpr_is_special(x) || fmpz_is_zero(y))
{
if (fmpr_is_zero(x))
{
fmpr_zero(z);
}
else if (fmpz_is_zero(y) && fmpr_is_finite(x))
{
fmpr_zero(z);
}
else if (fmpr_is_inf(x) && !fmpz_is_zero(y))
{
if (fmpr_sgn(x) == fmpz_sgn(y))
fmpr_pos_inf(z);
else
fmpr_neg_inf(z);
}
else
{
fmpr_nan(z);
}
return FMPR_RESULT_EXACT;
}
xv = *fmpr_manref(x);
yv = *y;
if (!COEFF_IS_MPZ(xv) && !COEFF_IS_MPZ(yv))
{
mp_limb_t ytmp;
unsigned int bc;
ytmp = FLINT_ABS(yv);
count_trailing_zeros(bc, ytmp);
ytmp >>= bc;
yexp = bc;
return _fmpr_mul_1x1(z, FLINT_ABS(xv), fmpr_expref(x),
ytmp, &yexp, (xv ^ yv) < 0, prec, rnd);
}
void
fmpr_pow_sloppy_fmpz(fmpr_t y, const fmpr_t b, const fmpz_t e,
long prec, fmpr_rnd_t rnd)
{
long i, wp, bits;
if (fmpz_is_zero(e))
{
fmpr_set_ui(y, 1UL);
return;
}
if (fmpz_sgn(e) < 0)
{
fmpz_t f;
fmpz_init(f);
fmpz_neg(f, e);
fmpr_pow_sloppy_fmpz(y, b, f, prec + 2,
(rnd == FMPR_RND_FLOOR || rnd == FMPR_RND_DOWN)
? FMPR_RND_UP : FMPR_RND_DOWN);
fmpr_ui_div(y, 1UL, y, prec, rnd);
fmpz_clear(f);
}
if (y == b)
{
fmpr_t t;
fmpr_init(t);
fmpr_set(t, b);
fmpr_pow_sloppy_fmpz(y, t, e, prec, rnd);
fmpr_clear(t);
return;
}
fmpr_set(y, b);
bits = fmpz_bits(e);
wp = FMPR_PREC_ADD(prec, bits);
for (i = bits - 2; i >= 0; i--)
{
fmpr_mul(y, y, y, wp, rnd);
if (fmpz_tstbit(e, i))
fmpr_mul(y, y, b, wp, rnd);
}
}
void
arb_bernoulli_fmpz(arb_t res, const fmpz_t n, slong prec)
{
if (fmpz_cmp_ui(n, UWORD_MAX) <= 0)
{
if (fmpz_sgn(n) >= 0)
arb_bernoulli_ui(res, fmpz_get_ui(n), prec);
else
arb_zero(res);
}
else if (fmpz_is_odd(n))
{
arb_zero(res);
}
else
{
arb_t t;
slong wp;
arb_init(t);
wp = prec + 2 * fmpz_bits(n);
/* zeta(n) ~= 1 */
arf_one(arb_midref(res));
mag_one(arb_radref(res));
mag_mul_2exp_si(arb_radref(res), arb_radref(res), WORD_MIN);
/* |B_n| = 2 * n! / (2*pi)^n * zeta(n) */
arb_gamma_fmpz(t, n, wp);
arb_mul_fmpz(t, t, n, wp);
arb_mul(res, res, t, wp);
arb_const_pi(t, wp);
arb_mul_2exp_si(t, t, 1);
arb_pow_fmpz(t, t, n, wp);
arb_div(res, res, t, prec);
arb_mul_2exp_si(res, res, 1);
if (fmpz_fdiv_ui(n, 4) == 0)
arb_neg(res, res);
arb_clear(t);
}
}
void fmpq_div_fmpz(fmpq_t res, const fmpq_t op, const fmpz_t x)
{
fmpz_t y;
fmpz_init(y);
fmpz_one(y);
_fmpq_mul(fmpq_numref(res), fmpq_denref(res),
fmpq_numref(op), fmpq_denref(op), y, x);
fmpz_clear(y);
if (fmpz_sgn(fmpq_denref(res)) < 0)
{
fmpz_neg(fmpq_numref(res), fmpq_numref(res));
fmpz_neg(fmpq_denref(res), fmpq_denref(res));
}
}
slong
_fmpz_sub_small_large(const fmpz_t x, const fmpz_t y)
{
fmpz_t t;
fmpz_init(t);
fmpz_sub(t, x, y);
if (!COEFF_IS_MPZ(*t))
{
/* no need to free t */
return *t;
}
else
{
int sign = fmpz_sgn(t);
fmpz_clear(t);
return (sign > 0) ? WORD_MAX : -WORD_MAX;
}
}
void
fmpz_poly_bit_pack(fmpz_t f, const fmpz_poly_t poly,
mp_bitcnt_t bit_size)
{
long len;
__mpz_struct * mpz;
long i, d;
int negate;
len = fmpz_poly_length(poly);
if (len == 0 || bit_size == 0)
{
fmpz_zero(f);
return;
}
mpz = _fmpz_promote(f);
mpz_realloc2(mpz, len * bit_size);
d = mpz->_mp_alloc;
mpn_zero(mpz->_mp_d, d);
if (fmpz_sgn(fmpz_poly_lead(poly)) < 0)
negate = -1;
else
negate = 0;
_fmpz_poly_bit_pack(mpz->_mp_d, poly->coeffs, len, bit_size, negate);
for (i = d - 1; i >= 0; i--)
{
if (mpz->_mp_d[i] != 0)
break;
}
d = i + 1;
mpz->_mp_size = d;
_fmpz_demote_val(f);
if (negate)
fmpz_neg(f, f);
}
void
fmpz_poly_bit_unpack(fmpz_poly_t poly, const fmpz_t f, mp_bitcnt_t bit_size)
{
slong len;
mpz_t tmp;
int negate, borrow;
if (bit_size == 0 || fmpz_is_zero(f))
{
fmpz_poly_zero(poly);
return;
}
/* Round up */
len = (fmpz_bits(f) + bit_size - 1) / bit_size;
negate = (fmpz_sgn(f) < 0) ? -1 : 0;
mpz_init2(tmp, bit_size*len);
/* TODO: avoid all this wastefulness */
flint_mpn_zero(tmp->_mp_d, tmp->_mp_alloc);
fmpz_get_mpz(tmp, f);
fmpz_poly_fit_length(poly, len + 1);
borrow = _fmpz_poly_bit_unpack(poly->coeffs, len,
tmp->_mp_d, bit_size, negate);
if (borrow)
{
fmpz_set_si(poly->coeffs + len, negate ? WORD(-1) : WORD(1));
_fmpz_poly_set_length(poly, len + 1);
}
else
{
_fmpz_poly_set_length(poly, len);
_fmpz_poly_normalise(poly);
}
mpz_clear(tmp);
}
void arith_euler_phi(fmpz_t res, const fmpz_t n)
{
fmpz_factor_t factors;
fmpz_t t;
ulong exp;
slong i;
if (fmpz_sgn(n) <= 0)
{
fmpz_zero(res);
return;
}
if (fmpz_abs_fits_ui(n))
{
fmpz_set_ui(res, n_euler_phi(fmpz_get_ui(n)));
return;
}
fmpz_factor_init(factors);
fmpz_factor(factors, n);
fmpz_one(res);
fmpz_init(t);
for (i = 0; i < factors->num; i++)
{
fmpz_sub_ui(t, factors->p + i, UWORD(1));
fmpz_mul(res, res, t);
exp = factors->exp[i];
if (exp != 1)
{
fmpz_pow_ui(t, factors->p + i, exp - UWORD(1));
fmpz_mul(res, res, t);
}
}
fmpz_clear(t);
fmpz_factor_clear(factors);
}
int
elem_leading_sign(elem_srcptr x, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
return fmpz_sgn(x);
case TYPE_POLY:
{
const elem_poly_struct * poly = x;
if (poly->length == 0)
return 0;
else
return elem_leading_sign(INDEX(poly->coeffs, poly->length - 1,
RING_PARENT(ring)->size), RING_PARENT(ring));
}
default:
NOT_IMPLEMENTED("leading_sign", ring);
}
}
