static void
obf_randomize_layer(obf_state_t *s, long nrows, long ncols,
encode_layer_randomization_flag_t rflag,
uint64_t n, fmpz_mat_t *mats)
{
fmpz_t *fields;
fields = s->vtable->sk->plaintext_fields(s->mmap);
if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_FIRST) {
fmpz_mat_t first;
_fmpz_mat_init_diagonal_rand(first, nrows, s->rand, fields[0]);
fmpz_layer_mul_left(n, mats, first, fields[0]);
fmpz_mat_clear(first);
}
if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_LAST) {
fmpz_mat_t last;
_fmpz_mat_init_diagonal_rand(last, ncols, s->rand, fields[0]);
fmpz_layer_mul_right(n, mats, last, fields[0]);
fmpz_mat_clear(last);
}
if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_FIRST
&& rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_LAST) {
} else if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_FIRST) {
fmpz_mat_init(*s->randomizer, ncols, ncols);
fmpz_mat_init(*s->inverse, ncols, ncols);
_fmpz_mat_init_square_rand(s, *s->randomizer, *s->inverse, ncols,
s->rand, fields[0]);
fmpz_layer_mul_right(n, mats, *s->randomizer, fields[0]);
} else if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_MIDDLE) {
fmpz_layer_mul_left(n, mats, *s->inverse, fields[0]);
fmpz_mat_clear(*s->randomizer);
fmpz_mat_clear(*s->inverse);
fmpz_mat_init(*s->randomizer, ncols, ncols);
fmpz_mat_init(*s->inverse, ncols, ncols);
_fmpz_mat_init_square_rand(s, *s->randomizer, *s->inverse, ncols,
s->rand, fields[0]);
fmpz_layer_mul_right(n, mats, *s->randomizer, fields[0]);
} else if (rflag & ENCODE_LAYER_RANDOMIZATION_TYPE_LAST) {
fmpz_layer_mul_left(n, mats, *s->inverse, fields[0]);
fmpz_mat_clear(*s->randomizer);
fmpz_mat_clear(*s->inverse);
}
{
fmpz_t alpha;
fmpz_init(alpha);
for (uint64_t i = 0; i < n; ++i) {
do {
fmpz_randm_aes(alpha, s->rand, fields[0]);
} while (fmpz_cmp_ui(alpha, 0) == 0);
fmpz_mat_scalar_mul_fmpz(mats[i], mats[i], alpha);
}
fmpz_clear(alpha);
}
free(fields);
}
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
partitions_fmpz_fmpz_hrr(fmpz_t p, const fmpz_t n, int use_doubles)
{
arb_t x;
arf_t bound;
slong N;
arb_init(x);
arf_init(bound);
N = partitions_hrr_needed_terms(fmpz_get_d(n));
if (fmpz_cmp_ui(n, 4e8) >= 0 && flint_get_num_threads() > 1)
{
hrr_sum_threaded(x, n, N, use_doubles);
}
else
{
partitions_hrr_sum_arb(x, n, 1, N, use_doubles);
}
partitions_rademacher_bound(bound, n, N);
arb_add_error_arf(x, bound);
if (!arb_get_unique_fmpz(p, x))
{
flint_printf("not unique!\n");
arb_printd(x, 50);
flint_printf("\n");
abort();
}
arb_clear(x);
arf_clear(bound);
}
int _arf_are_close(const arf_t x, const arf_t y, long prec)
{
fmpz_t xb, yb;
fmpz_t delta;
int result;
fmpz_init(xb);
fmpz_init(yb);
fmpz_init(delta);
arf_bot(xb, x);
arf_bot(yb, y);
if (fmpz_cmp(ARF_EXPREF(x), ARF_EXPREF(y)) >= 0)
fmpz_sub(delta, xb, ARF_EXPREF(y));
else
fmpz_sub(delta, yb, ARF_EXPREF(x));
fmpz_sub_ui(delta, delta, 64);
result = (fmpz_cmp_ui(delta, prec) < 0);
fmpz_clear(xb);
fmpz_clear(yb);
fmpz_clear(delta);
return result;
}
void
test_1(fmpz_t n)
{
mpfr_t q0; mpfr_init(q0);
mpfr_t q1; mpfr_init(q1);
fmpz_t m; fmpz_init(m);
int c;
fmpz_get_mpfr( q0, n , MPFR_RNDA );
fmpz_get_mpfr_3arg(q1, n[0], MPFR_RNDA );
assert( mpfr_equal_p( q0, q1 ) );
fmpz_set_mpfr(m, q0, MPFR_RNDA);
if( fmpz_cmp_ui( n, WORD(0) ) >= 0 )
{
if( fmpz_cmp(n,m) > 0 )
{
flint_printf("RNDA test failed, n="); fmpz_print(n);
flint_printf(", m="); fmpz_print(m); flint_printf("\n");
assert(0);
}
fmpz_sub(m, m, n);
IF_MORE_THAN_2;
}
else
{
if( fmpz_cmp(n,m) < 0 )
{
flint_printf("RNDA test failed, n="); fmpz_print(n);
flint_printf(", m="); fmpz_print(m); flint_printf("\n");
assert(0);
}
fmpz_sub(m, n, m);
IF_MORE_THAN_2;
}
fmpz_get_mpfr( q0, n, MPFR_RNDZ );
fmpz_set_mpfr( m, q0, MPFR_RNDZ );
c=fmpz_cmp_si( n, WORD(0) );
if(c==0)
assert(0 == fmpz_cmp_si(m,WORD(0)));
else
{
if(c<0)
{
fmpz_neg(n, n);
fmpz_neg(m, m);
}
assert( fmpz_cmp(n,m) >= 0 );
if(c)
assert( fmpz_cmp_si(m,WORD(0)) >= 0 );
fmpz_sub(m, n, m);
IF_MORE_THAN_2_AGAIN;
}
fmpz_clear(m);
mpfr_clear(q1);
mpfr_clear(q0);
}
static void
_fmpz_mat_init_diagonal_rand(fmpz_mat_t mat, long n, aes_randstate_t rand,
fmpz_t field)
{
fmpz_mat_init(mat, n, n);
fmpz_mat_one(mat);
for (int i = 0; i < n; i++) {
do {
fmpz_randm_aes(fmpz_mat_entry(mat, i, i), rand, field);
} while (fmpz_cmp_ui(fmpz_mat_entry(mat, i, i), 0) == 0);
}
}
static __inline__
long _zeta_function(const fmpz_t p, long a,
long n, long d)
{
const long b = gmc_basis_size(n, d);
long i, N;
fmpz_t f, g, max;
fmpz_init(f);
fmpz_init(g);
fmpz_init(max);
if (n == 3 && fmpz_cmp_ui(p, 2) != 0)
{
fmpz_bin_uiui(f, d-1, 3);
fmpz_bin_uiui(g, b, b / 2);
fmpz_mul_ui(g, g, 2);
N = a * (*f) + fmpz_clog(g, p);
}
else if (n % 2L == 0) /* n even implies b even */
{
fmpz_bin_uiui(f, b, b / 2);
fmpz_pow_ui(g, p, (a * (b / 2) * (n - 1) + 1) / 2);
fmpz_mul(f, f, g);
fmpz_mul_ui(f, f, 2);
N = fmpz_flog(f, p) + 1;
}
else
{
for (i = b / 2; i <= b; i++)
{
fmpz_bin_uiui(f, b, i);
fmpz_pow_ui(g, p, (a * i * (n - 1) + 1) / 2);
fmpz_mul(f, f, g);
fmpz_mul_ui(f, f, 2);
if (fmpz_cmp(max, f) < 0)
fmpz_swap(max, f);
}
N = fmpz_flog(max, p) + 1;
}
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(max);
return N;
}
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);
}
}
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
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);
}
}
/*
Returns data $N_1 = N_0 + r + s$ such that, in order to determine the
coefficients of the characteristic polynomial of $p^{-1} F_p$ to $p$-adic
precision $N_0$ it suffices to compute the matrix to precision $N_1$.
When $X$ is a smooth projective surface and $p > 2$, we can do better
by instead computing $q^{h_{0,2}} f(T/q)$, in which case the extraction
of the polynomial requires an extra $a$ digits of precision.
*/
static __inline__
long _frobq(long *r, long *s, const fmpz_t p, long a, long n, long d, long N0)
{
if (n == 3 && fmpz_cmp_ui(p, 2) != 0)
{
*r = 0;
*s = 0;
return N0 + a;
}
else
{
*r = padic_val_fac_ui(n - 1, p);
*s = (n + 1) * n_flog(n - 1, *p);
return N0 + *r + *s;
}
}
void test1(mp_limb_t log2,const fmpz_t b,const fmpz_t z)
{
if( (fmpz_cmp_ui(z,0)<=0) || (log2==0) )
return;
int r0=fmpz_cmpabs(z,b);
int r1=cmp_positive_log2(z,log2);
#if LOUD
fmpz_hex_print("2**y=",b,0);
fmpz_hex_print(" z=",z,0);
flint_printf(" r0/1: %d/%d\n",r0,r1);
#endif
if( r0>0 )
assert( r1>0 );
if( r0<0 )
assert( r1<0 );
if( r0==0 )
assert( 0 == r1 );
}
int
main(void)
{
long m, n, i, j, rep;
flint_rand_t state;
printf("unit....");
fflush(stdout);
flint_randinit(state);
for (rep = 0; rep < 1000; rep++)
{
fmpz_mat_t A;
m = n_randint(state, 20);
n = n_randint(state, 20);
fmpz_mat_init(A, m, n);
fmpz_mat_randtest(A, state, 100);
fmpz_mat_unit(A);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
if (fmpz_cmp_ui(fmpz_mat_entry(A,i,j), i == j) != 0)
{
printf("FAIL: nonzero entry\n");
abort();
}
}
}
fmpz_mat_clear(A);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
dedekind_sum_coprime(fmpq_t s, const fmpz_t h, const fmpz_t k)
{
if (fmpz_cmp_ui(k, DOUBLE_CUTOFF) < 0)
{
double t;
t = dedekind_sum_coprime_d(*h, *k) * (6 * (*k));
/* Round to nearest after truncation */
if (t > 0)
t += 0.5;
else
t -= 0.5;
fmpz_set_d(fmpq_numref(s), t);
fmpz_set_ui(fmpq_denref(s), 6UL * (*k));
fmpq_canonicalise(s);
}
else
{
dedekind_sum_coprime_large(s, h, k);
}
}
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);
}
}
// Version Fq
void fq_poly_compose_mod_kedlaya_umans(fq_poly_t fg, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, slong d, fq_ctx_t ctx) {
slong n, i, j, m, dm, N, Nm, degree;
fmpz* p;
fmpz_t q;
fq_multi_poly_t f_prime;
fq_struct *vect_beta, *vect_alpha, *vect_alpha2, *vect_eval;
fq_poly_t gi;
// Vérification des paramètres
n = FLINT_MAX(fq_poly_length(f,ctx),fq_poly_length(g,ctx));
i = fq_poly_length(h,ctx);
if(n >= i) {
printf("Erreur, f ou g n'a pas été modulé par h.\n");
exit(1);
}
// Les polynômes f et g étant réduits modulo h, n vaut le nombre de coefficients de h
n = i;
if(d < 2) {
printf("d < 2\n");
exit(1);
}
if(d >= n) {
printf("d >= n\n");
exit(1);
}
p = fq_ctx_prime(ctx);
degree = fq_ctx_degree(ctx);
m = n_clog(n,d);
dm = n_pow(d,m);
N = n_pow(d,m)*m*d;
Nm = N*m;
if(fmpz_cmp_ui(p,N) < 0) {
flint_printf("\nErreur, pas assez de points d'interpolation !\n");
flint_printf("\np tient sur un mot machine, utilisez donc la version fq_nmod !\n");
exit(1);
}
// Étape 1 //////////////////////////////
fq_multi_poly_init(f_prime, dm, d, m, ctx);
_fq_vec_zero(f_prime->poly, dm, ctx);
for(i = 0 ; i < n ; i++) {
fq_poly_get_coeff(&(f_prime->poly[i]),f,i,ctx);
}
// Étape 3 //////////////////////////////
vect_beta = _fq_vec_init(N,ctx);
for(i = 0 ; i < N ; i++) {
fmpz_poly_set_coeff_ui(vect_beta + i, 0, i);
}
vect_alpha = _fq_vec_init(N*m, ctx);
fq_poly_init(gi,ctx);
fq_poly_set(gi,g,ctx);
fq_poly_evaluate_fq_vec(vect_alpha, gi, vect_beta, N, ctx);
for(i = 1 ; i < m ; i++) {
// Étape 2 //////////////////////////////
// Calcul du g^(d^i) avec g^(d^i) = [ (g^(d^(i-1))) ^ d ] mod h
fq_poly_powmod_ui_binexp(gi,gi,d,h,ctx);
fq_poly_evaluate_fq_vec(vect_alpha+i*N, gi, vect_beta, N, ctx);
}
fq_poly_clear(gi, ctx);
// Transposition
// Passe de m lignes N colonnes
// à N lignes m colonnes ==> nécessaire pour EMM dans Fp
vect_alpha2 = _fq_vec_init(Nm,ctx);
for(i = 0 ; i < m ; i++) {
for(j = 0 ; j < N ; j++) {
fq_set(vect_alpha2 + j*m + i,vect_alpha + i*N + j,ctx);
}
}
vect_alpha = vect_alpha2;
// Étape 4 //////////////////////////////
// EMM
vect_eval = _fq_vec_init(N,ctx);
fq_multi_poly_multimodular(vect_eval, N, f_prime, vect_alpha, ctx);
_fq_vec_clear(vect_alpha,Nm,ctx);
fq_multi_poly_clear(f_prime,ctx);
// Étape 5 //////////////////////////////
fq_poly_interpolate_fq_vec_fast(fg, vect_beta, vect_eval, N, ctx);
_fq_vec_clear(vect_beta,N,ctx);
_fq_vec_clear(vect_eval,N,ctx);
// Étape 6 //////////////////////////////
fq_poly_rem(fg,fg,h,ctx);
}
static __inline__ void
_arb_vec_get_fmpz_2exp_blocks(fmpz * coeffs, fmpz * exps,
slong * blocks, const fmpz_t scale, arb_srcptr x, slong len, slong prec)
{
fmpz_t top, bot, t, b, v, block_top, block_bot;
slong i, j, s, block, bits, maxheight;
int in_zero;
fmpz_init(top);
fmpz_init(bot);
fmpz_init(t);
fmpz_init(b);
fmpz_init(v);
fmpz_init(block_top);
fmpz_init(block_bot);
blocks[0] = 0;
block = 0;
in_zero = 1;
if (prec == ARF_PREC_EXACT)
maxheight = ARF_PREC_EXACT;
else
maxheight = ALPHA * prec + BETA;
for (i = 0; i < len; i++)
{
bits = arf_bits(arb_midref(x + i));
/* Skip (must be zero, since we assume there are no Infs/NaNs). */
if (bits == 0)
continue;
/* Bottom and top exponent of current number */
fmpz_set(top, ARF_EXPREF(arb_midref(x + i)));
fmpz_submul_ui(top, scale, i);
fmpz_sub_ui(bot, top, bits);
/* Extend current block. */
if (in_zero)
{
fmpz_swap(block_top, top);
fmpz_swap(block_bot, bot);
}
else
{
fmpz_max(t, top, block_top);
fmpz_min(b, bot, block_bot);
fmpz_sub(v, t, b);
/* extend current block */
if (fmpz_cmp_ui(v, maxheight) < 0)
{
fmpz_swap(block_top, t);
fmpz_swap(block_bot, b);
}
else /* start new block */
{
/* write exponent for previous block */
fmpz_set(exps + block, block_bot);
block++;
blocks[block] = i;
fmpz_swap(block_top, top);
fmpz_swap(block_bot, bot);
}
}
in_zero = 0;
}
/* write exponent for last block */
fmpz_set(exps + block, block_bot);
/* end marker */
blocks[block + 1] = len;
/* write the block data */
for (i = 0; blocks[i] != len; i++)
{
for (j = blocks[i]; j < blocks[i + 1]; j++)
{
if (arf_is_special(arb_midref(x + j)))
{
fmpz_zero(coeffs + j);
}
else
{
/* TODO: make this a single operation */
arf_get_fmpz_2exp(coeffs + j, bot, arb_midref(x + j));
fmpz_mul_ui(t, scale, j);
fmpz_sub(t, bot, t);
s = _fmpz_sub_small(t, exps + i);
if (s < 0) abort(); /* Bug catcher */
fmpz_mul_2exp(coeffs + j, coeffs + j, s);
}
}
}
fmpz_clear(top);
fmpz_clear(bot);
fmpz_clear(t);
fmpz_clear(b);
fmpz_clear(v);
fmpz_clear(block_top);
fmpz_clear(block_bot);
}
static __inline__ void
_mag_vec_get_fmpz_2exp_blocks(fmpz * coeffs,
double * dblcoeffs, fmpz * exps, slong * blocks, const fmpz_t scale,
arb_srcptr x, mag_srcptr xm, slong len)
{
fmpz_t top, bot, t, b, v, block_top, block_bot;
slong i, j, s, block, bits, maxheight;
int in_zero;
mag_srcptr cur;
fmpz_init(top);
fmpz_init(bot);
fmpz_init(t);
fmpz_init(b);
fmpz_init(v);
fmpz_init(block_top);
fmpz_init(block_bot);
blocks[0] = 0;
block = 0;
in_zero = 1;
maxheight = ALPHA * MAG_BITS + BETA;
if (maxheight > DOUBLE_BLOCK_MAX_HEIGHT)
abort();
for (i = 0; i < len; i++)
{
cur = (x == NULL) ? (xm + i) : arb_radref(x + i);
/* Skip (must be zero, since we assume there are no Infs/NaNs). */
if (mag_is_special(cur))
continue;
/* Bottom and top exponent of current number */
bits = MAG_BITS;
fmpz_set(top, MAG_EXPREF(cur));
fmpz_submul_ui(top, scale, i);
fmpz_sub_ui(bot, top, bits);
/* Extend current block. */
if (in_zero)
{
fmpz_swap(block_top, top);
fmpz_swap(block_bot, bot);
}
else
{
fmpz_max(t, top, block_top);
fmpz_min(b, bot, block_bot);
fmpz_sub(v, t, b);
/* extend current block */
if (fmpz_cmp_ui(v, maxheight) < 0)
{
fmpz_swap(block_top, t);
fmpz_swap(block_bot, b);
}
else /* start new block */
{
/* write exponent for previous block */
fmpz_set(exps + block, block_bot);
block++;
blocks[block] = i;
fmpz_swap(block_top, top);
fmpz_swap(block_bot, bot);
}
}
in_zero = 0;
}
/* write exponent for last block */
fmpz_set(exps + block, block_bot);
/* end marker */
blocks[block + 1] = len;
/* write the block data */
for (i = 0; blocks[i] != len; i++)
{
for (j = blocks[i]; j < blocks[i + 1]; j++)
{
cur = (x == NULL) ? (xm + j) : arb_radref(x + j);
if (mag_is_special(cur))
{
fmpz_zero(coeffs + j);
dblcoeffs[j] = 0.0;
}
else
{
mp_limb_t man;
double c;
man = MAG_MAN(cur);
/* TODO: only write and use doubles when block is short? */
/* Divide by 2^(scale * j) */
fmpz_mul_ui(t, scale, j);
fmpz_sub(t, MAG_EXPREF(cur), t);
fmpz_sub_ui(t, t, MAG_BITS); /* bottom exponent */
s = _fmpz_sub_small(t, exps + i);
if (s < 0) abort(); /* Bug catcher */
fmpz_set_ui(coeffs + j, man);
fmpz_mul_2exp(coeffs + j, coeffs + j, s);
c = man;
c = ldexp(c, s - DOUBLE_BLOCK_SHIFT);
if (c < 1e-150 || c > 1e150) /* Bug catcher */
abort();
dblcoeffs[j] = c;
}
}
}
fmpz_clear(top);
fmpz_clear(bot);
fmpz_clear(t);
fmpz_clear(b);
fmpz_clear(v);
fmpz_clear(block_top);
fmpz_clear(block_bot);
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("reconstruct_fmpz_2....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
int result;
int modresult;
int special_case;
fmpq_t x, y;
fmpz_t mod, res, N, D, t;
mpz_t tmp;
fmpq_init(x);
fmpq_init(y);
fmpz_init(mod);
fmpz_init(res);
fmpz_init(N);
fmpz_init(D);
fmpz_init(t);
mpz_init(tmp);
fmpq_randtest(x, state, 100);
fmpz_abs(N, fmpq_numref(x));
fmpz_set(D, fmpq_denref(x));
/* Randomly generate larger bounds */
if (n_randint(state, 2))
{
fmpz_randtest_not_zero(t, state, 100);
fmpz_abs(t, t);
fmpz_mul(N, N, t);
}
if (n_randint(state, 2))
{
fmpz_randtest_not_zero(t, state, 100);
fmpz_abs(t, t);
fmpz_mul(D, D, t);
}
fmpz_mul(mod, N, D);
fmpz_mul_ui(mod, mod, UWORD(2));
/* Next prime greater than or equal */
fmpz_get_mpz(tmp, mod);
flint_mpz_sub_ui(tmp, tmp, UWORD(1));
mpz_nextprime(tmp, tmp);
fmpz_set_mpz(mod, tmp);
modresult = fmpq_mod_fmpz(res, x, mod);
result = fmpq_reconstruct_fmpz_2(y, res, mod, N, D);
/* Special case: both 1 and -1 have residue 1 mod 2.
There's probably no particular reason to disallow this. */
special_case = (fmpz_cmp_ui(mod, UWORD(2)) == 0 &&
fmpz_get_si(&x->num) == WORD(-1) &&
fmpz_cmp_ui(&x->den, UWORD(1)) == 0);
if (special_case)
{
if (!modresult || !result ||
!fmpz_is_one(&y->num) || !fmpz_is_one(&y->den))
{
flint_printf("FAIL: special case: -1 mod 2\n");
abort();
}
}
else if (!modresult || !result || !fmpq_equal(x, y))
{
flint_printf("FAIL: reconstruction failed\n");
flint_printf("input = ");
fmpq_print(x);
flint_printf("\nmodulus = ");
fmpz_print(mod);
flint_printf("\nresidue = ");
fmpz_print(res);
flint_printf("\nreconstructed = ");
fmpq_print(y);
flint_printf("\nfmpq_mod_fmpz return value = %d", modresult);
flint_printf("\nfmpq_reconstruct_fmpz return value = %d", result);
flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(mod);
fmpz_clear(res);
fmpz_clear(N);
fmpz_clear(D);
fmpz_clear(t);
mpz_clear(tmp);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
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;
}
int main(void)
{
int i, j, result;
ulong count = UWORD(0);
gmp_randstate_t st;
FLINT_TEST_INIT(state);
gmp_randinit_default(st);
flint_printf("factor_pp1....");
fflush(stdout);
for (i = 0; i < 50 * flint_test_multiplier(); i++) /* Test random numbers */
{
mp_bitcnt_t bits;
mpz_t m, n;
fmpz_t n1, n2, r;
mpz_init(n);
mpz_init(m);
fmpz_init(n1);
fmpz_init(n2);
fmpz_init(r);
do {
mpz_urandomb(n, st, n_randint(state, 128) + 2);
} while (flint_mpz_cmp_ui(n, 2) < 0);
do {
mpz_urandomb(m, st, n_randint(state, 50) + 2);
} while (!mpz_probab_prime_p(m, 20));
mpz_mul(n, n, m);
fmpz_set_mpz(n1, n);
bits = FLINT_MIN(fmpz_bits(n1), FLINT_BITS);
for (j = 0; j < 20; j++)
{
fmpz_factor_pp1(n2, n1, 10000, 10000, n_randbits(state, bits - 2) + 3);
if (fmpz_cmp_ui(n2, 1) > 0) break;
}
if (fmpz_cmp_ui(n2, 1) > 0)
{
count++;
fmpz_mod(r, n1, n2);
result = (fmpz_is_zero(r));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n1 = ");
fmpz_print(n1);
flint_printf(", n2 = ");
fmpz_print(n2);
flint_printf("\n");
fmpz_print(r); flint_printf("\n");
abort();
}
}
fmpz_clear(n1);
fmpz_clear(n2);
fmpz_clear(r);
mpz_clear(m);
mpz_clear(n);
}
if (count < 49 * flint_test_multiplier())
{
flint_printf("FAIL:\n");
flint_printf("Only %wu numbers factored\n", count);
abort();
}
gmp_randclear(st);
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;
}
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)
{
long iter;
int result;
flint_rand_t state;
printf("abs_ubound_ui_2exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpz_t x, y;
long bits, yexp;
long exp;
mp_limb_t man;
fmpz_init(x);
fmpz_init(y);
fmpz_randtest_not_zero(x, state, 1 + n_randint(state, 400));
bits = 1 + n_randint(state, FLINT_BITS - 1);
/* compute an exactly rounded mantissa */
fmpz_abs(y, x);
if (fmpz_is_zero(y))
{
yexp = 0;
}
else
{
yexp = fmpz_bits(y) - bits;
if (yexp >= 0)
{
fmpz_cdiv_q_2exp(y, y, yexp);
if (fmpz_bits(y) == bits + 1)
{
fmpz_tdiv_q_2exp(y, y, 1);
yexp--;
}
}
else
{
fmpz_mul_2exp(y, y, -yexp);
}
}
man = fmpz_abs_ubound_ui_2exp(&exp, x, bits);
if (FLINT_BIT_COUNT(man) != bits)
{
printf("wrong number of bits!\n");
printf("bits = %ld, count = %u\n\n", bits, FLINT_BIT_COUNT(man));
printf("x = "); fmpz_print(x); printf("\n\n");
printf("bits(x) = %ld\n\n", fmpz_bits(x));
printf("y = "); fmpz_print(y); printf("\n\n");
printf("yexp = %ld\n\n", yexp);
printf("man = %lu, exp = %ld\n", man, exp);
abort();
}
/* ok if equal */
result = (fmpz_cmp_ui(y, man) == 0);
/* ok if mantissa is 1 larger */
if (!result)
{
result = ((exp == yexp) && (fmpz_cmp_ui(y, man - 1) == 0));
}
/* ok if the exact mantissa is 2^r-1 and overflow to 2^r happened */
if (!result)
{
fmpz_t t;
fmpz_init(t);
fmpz_set_ui(t, man);
fmpz_mul_ui(t, t, 2);
fmpz_sub_ui(t, t, 1);
result = (exp == yexp + 1) && fmpz_equal(t, y);
fmpz_clear(t);
}
if (!result)
{
printf("different from exact ceiling division\n");
printf("bits = %ld\n\n", bits);
printf("x = "); fmpz_print(x); printf("\n\n");
printf("bits(x) = %ld\n\n", fmpz_bits(x));
printf("y = "); fmpz_print(y); printf(", yexp = %ld\n\n", yexp);
printf("man = %lu, exp = %ld\n", man, exp);
abort();
}
fmpz_clear(x);
fmpz_clear(y);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
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);
}
