int fmpz_moebius_mu(const fmpz_t n)
{
fmpz_factor_t factors;
long i;
int mu;
if (fmpz_abs_fits_ui(n))
return n_moebius_mu(fmpz_get_ui(n));
fmpz_factor_init(factors);
fmpz_factor(factors, n);
mu = 1;
for (i = 0; i < factors->num; i++)
{
if (fmpz_get_ui(factors->exp + i) != 1UL)
{
mu = 0;
break;
}
}
if (factors->num % 2)
mu = -mu;
fmpz_factor_clear(factors);
return mu;
}
void _fmpz_ramanujan_tau(fmpz_t res, fmpz_factor_t factors)
{
fmpz_poly_t poly;
fmpz_t tau_p, p_11, next, this, prev;
long k, r;
ulong max_prime;
max_prime = 1UL;
for (k = 0; k < factors->length; k++)
{
/* TODO: handle overflow properly */
max_prime = FLINT_MAX(max_prime, fmpz_get_ui(factors->p + k));
}
fmpz_poly_init(poly);
fmpz_poly_ramanujan_tau(poly, max_prime + 1);
fmpz_set_ui(res, 1);
fmpz_init(tau_p);
fmpz_init(p_11);
fmpz_init(next);
fmpz_init(this);
fmpz_init(prev);
for (k = 0; k < factors->length; k++)
{
ulong p = fmpz_get_ui(factors->p + k);
fmpz_set(tau_p, poly->coeffs + p);
fmpz_set_ui(p_11, p);
fmpz_pow_ui(p_11, p_11, 11);
fmpz_set_ui(prev, 1);
fmpz_set(this, tau_p);
for (r = 1; r < fmpz_get_ui(factors->exp + k); r++)
{
fmpz_mul(next, tau_p, this);
fmpz_submul(next, p_11, prev);
fmpz_set(prev, this);
fmpz_set(this, next);
}
fmpz_mul(res, res, this);
}
fmpz_clear(tau_p);
fmpz_clear(p_11);
fmpz_clear(next);
fmpz_clear(this);
fmpz_clear(prev);
fmpz_poly_clear(poly);
}
void _fmpq_poly_scalar_div_ui(fmpz * rpoly, fmpz_t rden, const fmpz * poly,
const fmpz_t den, long len, ulong c)
{
if (c == 1UL)
{
if (rpoly != poly)
_fmpz_vec_set(rpoly, poly, len);
fmpz_set(rden, den);
}
else
{
fmpz_t d, fc;
ulong ud;
fmpz_init(d);
fmpz_init(fc);
_fmpz_vec_content(d, poly, len);
fmpz_set_ui(fc, c);
fmpz_gcd(d, d, fc);
ud = fmpz_get_ui(d); /* gcd of d and c fits into a ulong */
_fmpz_vec_scalar_divexact_ui(rpoly, poly, len, ud);
fmpz_mul_ui(rden, den, c / ud);
fmpz_clear(d);
fmpz_clear(fc);
}
}
void padic_ctx_init(padic_ctx_t ctx, const fmpz_t p, long N,
enum padic_print_mode mode)
{
fmpz_init(ctx->p);
fmpz_set(ctx->p, p);
ctx->N = N;
ctx->pinv = (!COEFF_IS_MPZ(*p)) ? n_precompute_inverse(fmpz_get_ui(p)) : 0;
if (N > 0)
{
long i, len;
ctx->min = FLINT_MAX(1, N - 10);
ctx->max = N + 10;
len = ctx->max - ctx->min;
ctx->pow = _fmpz_vec_init(len);
fmpz_pow_ui(ctx->pow, p, ctx->min);
for (i = 1; i < len; i++)
fmpz_mul(ctx->pow + i, ctx->pow + (i - 1), p);
}
else
{
ctx->min = 0;
ctx->max = 0;
ctx->pow = NULL;
}
ctx->mode = mode;
}
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
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_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);
}
}
/*
Returns $\ord_p(N!)$.
Note that since $N$ fits into an \code{unsigned long}, so does
$\ord_p(N!)$ since $\ord_p{N!) \leq (N - 1) / (p - 1)$.
*/
ulong padic_val_fac_ui(ulong N, const fmpz_t p)
{
if (fmpz_abs_fits_ui(p))
{
ulong q = fmpz_get_ui(p), s = 0, t = N;
do
{
t /= q;
s += t;
}
while (t);
return s;
}
else
{
return 0;
}
}
void
fq_zech_ctx_randtest(fq_zech_ctx_t ctx, flint_rand_t state)
{
fmpz_t p;
slong max_d, d;
fq_nmod_ctx_struct * fq_nmod_ctx;
fq_nmod_ctx = flint_malloc(sizeof(fq_nmod_ctx_struct));
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 2 + n_randint(state, 4), 1));
max_d = floor(log(n_pow(2, 16)) / log(fmpz_get_ui(p)));
d = n_randint(state, max_d - 1) + 2;
fq_nmod_ctx_init(fq_nmod_ctx, p, d, "a");
fq_zech_ctx_init_fq_nmod_ctx(ctx, fq_nmod_ctx);
fmpz_clear(p);
ctx->owns_fq_nmod_ctx = 1;
}
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);
}
/*
Divide (arrayg, limbsg) by the positive value gc inplace and
return the number of limbs written
*/
mp_size_t mpn_tdiv_q_fmpz_inplace(mp_ptr arrayg, mp_size_t limbsg, fmpz_t gc)
{
if (fmpz_size(gc) == 1)
{
mpn_divmod_1(arrayg, arrayg, limbsg, fmpz_get_ui(gc));
return limbsg - (arrayg[limbsg - 1] == 0);
}
else
{
mp_size_t tlimbs;
__mpz_struct * mpz_ptr = COEFF_TO_PTR(*gc);
mp_ptr temp = flint_malloc(limbsg*sizeof(mp_limb_t));
mpn_copyi(temp, arrayg, limbsg);
mpn_tdiv_q(arrayg, temp, limbsg, mpz_ptr->_mp_d, mpz_ptr->_mp_size);
tlimbs = limbsg - mpz_ptr->_mp_size + 1;
tlimbs -= (arrayg[tlimbs - 1] == 0);
flint_free(temp);
return tlimbs;
}
}
int
arf_root(arf_ptr z, arf_srcptr x, ulong k, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, zn, val;
mp_srcptr xptr;
mp_ptr tmp, zptr;
mpfr_t xf, zf;
fmpz_t q, r;
int inexact;
if (k == 0)
{
arf_nan(z);
return 0;
}
if (k == 1)
return arf_set_round(z, x, prec, rnd);
if (k == 2)
return arf_sqrt(z, x, prec, rnd);
if (arf_is_special(x))
{
if (arf_is_neg_inf(x))
arf_nan(z);
else
arf_set(z, x);
return 0;
}
if (ARF_SGNBIT(x))
{
arf_nan(z);
return 0;
}
fmpz_init(q);
fmpz_init(r);
/* x = m * 2^e where e = qk + r */
/* x^(1/k) = (m * 2^(qk+r))^(1/k) */
/* x^(1/k) = (m * 2^r)^(1/k) * 2^q */
fmpz_set_ui(r, k);
fmpz_fdiv_qr(q, r, ARF_EXPREF(x), r);
ARF_GET_MPN_READONLY(xptr, xn, x);
zn = (prec + FLINT_BITS - 1) / FLINT_BITS;
zf->_mpfr_d = tmp = flint_malloc(zn * sizeof(mp_limb_t));
zf->_mpfr_prec = prec;
zf->_mpfr_sign = 1;
zf->_mpfr_exp = 0;
xf->_mpfr_d = (mp_ptr) xptr;
xf->_mpfr_prec = xn * FLINT_BITS;
xf->_mpfr_sign = 1;
xf->_mpfr_exp = fmpz_get_ui(r);
inexact = mpfr_root(zf, xf, k, arf_rnd_to_mpfr(rnd));
inexact = (inexact != 0);
val = 0;
while (tmp[val] == 0)
val++;
ARF_GET_MPN_WRITE(zptr, zn - val, z);
flint_mpn_copyi(zptr, tmp + val, zn - val);
fmpz_add_si(ARF_EXPREF(z), q, zf->_mpfr_exp);
flint_free(tmp);
fmpz_clear(q);
fmpz_clear(r);
return inexact;
}
void arb_fib_fmpz(arb_t f, const fmpz_t n, slong prec)
{
arb_t t, u;
slong wp, sign, i;
if (fmpz_sgn(n) < 0)
{
fmpz_t m;
fmpz_init(m);
fmpz_neg(m, n);
arb_fib_fmpz(f, m, prec);
if (fmpz_is_even(m))
arb_neg(f, f);
fmpz_clear(m);
return;
}
if (fmpz_cmp_ui(n, 4) <= 0)
{
ulong x = fmpz_get_ui(n);
arb_set_ui(f, x - (x > 1));
return;
}
wp = ARF_PREC_ADD(prec, 3 * fmpz_bits(n));
arb_init(u);
arb_init(t);
arb_set_ui(f, UWORD(1));
arb_set_ui(u, UWORD(1));
sign = -1;
for (i = fmpz_flog_ui(n, UWORD(2)) - 1; i > 0; i--)
{
arb_mul(t, f, f, wp);
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul(f, f, f, wp);
arb_mul_2exp_si(f, f, 1);
arb_submul_ui(f, t, 3, wp);
arb_sub_si(f, f, 2 * sign, wp);
arb_mul_ui(u, t, 5, wp);
arb_add_si(u, u, 2 * sign, wp);
sign = 1;
if (fmpz_tstbit(n, i))
{
arb_set(t, f);
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul_2exp_si(t, t, 1);
arb_add(u, f, t, wp);
sign = -1;
}
}
if (fmpz_tstbit(n, 0))
{
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul(f, f, u, wp);
arb_sub_si(f, f, sign, prec);
}
else
{
arb_mul(f, f, u, prec);
}
arb_clear(u);
arb_clear(t);
}
void
_arb_bell_sum_taylor(arb_t res, const fmpz_t n,
const fmpz_t a, const fmpz_t b, const fmpz_t mmag, long tol)
{
fmpz_t m, r, R, tmp;
mag_t B, C, D, bound;
arb_t t, u;
long wp, k, N;
if (_fmpz_sub_small(b, a) < 5)
{
arb_bell_sum_bsplit(res, n, a, b, mmag, tol);
return;
}
fmpz_init(m);
fmpz_init(r);
fmpz_init(R);
fmpz_init(tmp);
/* r = max(m - a, b - m) */
/* m = a + (b - a) / 2 */
fmpz_sub(r, b, a);
fmpz_cdiv_q_2exp(r, r, 1);
fmpz_add(m, a, r);
fmpz_mul_2exp(R, r, RADIUS_BITS);
mag_init(B);
mag_init(C);
mag_init(D);
mag_init(bound);
arb_init(t);
arb_init(u);
if (fmpz_cmp(R, m) >= 0)
{
mag_inf(C);
mag_inf(D);
}
else
{
/* C = exp(R * |F'(m)| + (1/2) R^2 * (n/(m-R)^2 + 1/(m-R))) */
/* C = exp(R * (|F'(m)| + (1/2) R * (n/(m-R) + 1)/(m-R))) */
/* D = (1/2) R * (n/(m-R) + 1)/(m-R) */
fmpz_sub(tmp, m, R);
mag_set_fmpz(D, n);
mag_div_fmpz(D, D, tmp);
mag_one(C);
mag_add(D, D, C);
mag_div_fmpz(D, D, tmp);
mag_mul_fmpz(D, D, R);
mag_mul_2exp_si(D, D, -1);
/* C = |F'(m)| */
wp = 20 + 1.05 * fmpz_bits(n);
arb_set_fmpz(t, n);
arb_div_fmpz(t, t, m, wp);
fmpz_add_ui(tmp, m, 1);
arb_set_fmpz(u, tmp);
arb_digamma(u, u, wp);
arb_sub(t, t, u, wp);
arb_get_mag(C, t);
/* C = exp(R * (C + D)) */
mag_add(C, C, D);
mag_mul_fmpz(C, C, R);
mag_exp(C, C);
}
if (mag_cmp_2exp_si(C, tol / 4 + 2) > 0)
{
_arb_bell_sum_taylor(res, n, a, m, mmag, tol);
_arb_bell_sum_taylor(t, n, m, b, mmag, tol);
arb_add(res, res, t, 2 * tol);
}
else
{
arb_ptr mx, ser1, ser2, ser3;
/* D = T(m) */
wp = 20 + 1.05 * fmpz_bits(n);
arb_set_fmpz(t, m);
arb_pow_fmpz(t, t, n, wp);
fmpz_add_ui(tmp, m, 1);
arb_gamma_fmpz(u, tmp, wp);
arb_div(t, t, u, wp);
arb_get_mag(D, t);
/* error bound: (b-a) * C * D * B^N / (1 - B), B = r/R */
/* ((b-a) * C * D * 2) * 2^(-N*RADIUS_BITS) */
/* ((b-a) * C * D * 2) */
mag_mul(bound, C, D);
mag_mul_2exp_si(bound, bound, 1);
fmpz_sub(tmp, b, a);
mag_mul_fmpz(bound, bound, tmp);
/* N = (tol + log2((b-a)*C*D*2) - mmag) / RADIUS_BITS */
if (mmag == NULL)
{
/* estimate D ~= 2^mmag */
fmpz_add_ui(tmp, MAG_EXPREF(C), tol);
fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS);
}
else
{
fmpz_sub(tmp, MAG_EXPREF(bound), mmag);
fmpz_add_ui(tmp, tmp, tol);
fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS);
}
if (fmpz_cmp_ui(tmp, 5 * tol / 4) > 0)
N = 5 * tol / 4;
else if (fmpz_cmp_ui(tmp, 2) < 0)
N = 2;
else
N = fmpz_get_ui(tmp);
/* multiply by 2^(-N*RADIUS_BITS) */
mag_mul_2exp_si(bound, bound, -N * RADIUS_BITS);
mx = _arb_vec_init(2);
ser1 = _arb_vec_init(N);
ser2 = _arb_vec_init(N);
ser3 = _arb_vec_init(N);
/* estimate (this should work for moderate n and tol) */
wp = 1.1 * tol + 1.05 * fmpz_bits(n) + 5;
/* increase precision until convergence */
while (1)
{
/* (m+x)^n / gamma(m+1+x) */
arb_set_fmpz(mx, m);
arb_one(mx + 1);
_arb_poly_log_series(ser1, mx, 2, N, wp);
for (k = 0; k < N; k++)
arb_mul_fmpz(ser1 + k, ser1 + k, n, wp);
arb_add_ui(mx, mx, 1, wp);
_arb_poly_lgamma_series(ser2, mx, 2, N, wp);
_arb_vec_sub(ser1, ser1, ser2, N, wp);
_arb_poly_exp_series(ser3, ser1, N, N, wp);
/* t = a - m, u = b - m */
arb_set_fmpz(t, a);
arb_sub_fmpz(t, t, m, wp);
arb_set_fmpz(u, b);
arb_sub_fmpz(u, u, m, wp);
arb_power_sum_vec(ser1, t, u, N, wp);
arb_zero(res);
for (k = 0; k < N; k++)
arb_addmul(res, ser3 + k, ser1 + k, wp);
if (mmag != NULL)
{
if (_fmpz_sub_small(MAG_EXPREF(arb_radref(res)), mmag) <= -tol)
break;
}
else
{
if (arb_rel_accuracy_bits(res) >= tol)
break;
}
wp = 2 * wp;
}
/* add the series truncation bound */
arb_add_error_mag(res, bound);
_arb_vec_clear(mx, 2);
_arb_vec_clear(ser1, N);
_arb_vec_clear(ser2, N);
_arb_vec_clear(ser3, N);
}
mag_clear(B);
mag_clear(C);
mag_clear(D);
mag_clear(bound);
arb_clear(t);
arb_clear(u);
fmpz_clear(m);
fmpz_clear(r);
fmpz_clear(R);
fmpz_clear(tmp);
}
int
main(void)
{
int i, j, result = 1;
fmpz_t t;
flint_rand_t state;
flint_randinit(state);
printf("derivative....");
fflush(stdout);
fmpz_init(t);
/* Check derivative by hand */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_derivative(b, a);
if (a->length <= 1)
result = (b->length == 0);
else
{
for (j = 1; j < a->length; j++)
{
fmpz_set_ui(t, nmod_poly_get_coeff_ui(a, j));
fmpz_mul_ui(t, t, j);
fmpz_mod_ui(t, t, n);
result &= (fmpz_get_ui(t) == nmod_poly_get_coeff_ui(b, j - 1));
}
}
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
fmpz_clear(t);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_derivative(b, a);
nmod_poly_derivative(a, a);
result = nmod_poly_equal(a, b);
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
unsigned int computeHashValue(const ElementType& a) const
{
unsigned long numhash = fmpz_get_ui(fmpq_numref(&a));
unsigned long denhash = fmpz_get_ui(fmpq_denref(&a));
return static_cast<unsigned int>(13253 * numhash + 7647 * denhash);
}
