void acb_lambertw_left(acb_t res, const acb_t z, const fmpz_t k, slong prec) { if (acb_contains_zero(z) && !(fmpz_equal_si(k, -1) && acb_is_real(z))) { acb_indeterminate(res); return; } if (arb_is_positive(acb_imagref(z))) { acb_lambertw(res, z, k, 0, prec); } else if (arb_is_nonpositive(acb_imagref(z))) { fmpz_t kk; fmpz_init(kk); fmpz_add_ui(kk, k, 1); fmpz_neg(kk, kk); acb_conj(res, z); acb_lambertw(res, res, kk, 0, prec); acb_conj(res, res); fmpz_clear(kk); } else { acb_t za, zb; fmpz_t kk; acb_init(za); acb_init(zb); fmpz_init(kk); acb_set(za, z); acb_conj(zb, z); arb_nonnegative_part(acb_imagref(za), acb_imagref(za)); arb_nonnegative_part(acb_imagref(zb), acb_imagref(zb)); fmpz_add_ui(kk, k, 1); fmpz_neg(kk, kk); acb_lambertw(za, za, k, 0, prec); acb_lambertw(zb, zb, kk, 0, prec); acb_conj(zb, zb); acb_union(res, za, zb, prec); acb_clear(za); acb_clear(zb); fmpz_clear(kk); } }
void fmpz_add_n(fmpz_t f, const fmpz_t g, const fmpz_t h) { if (!g && !h) { fmpz_zero(f); } else { if (!g && h) fmpz_add_ui(f, h, 0); else if (g && !h) fmpz_add_ui(f, g, 0); else fmpz_add(f, g, h); } }
slong hypgeom_root_norm(const fmpz_poly_t P) { slong res, i, p; fmpz_t t, A; fmpz_init(A); fmpz_init(t); p = fmpz_poly_degree(P); fmpz_zero(A); for (i = 1; i <= p; i++) { fmpz_cdiv_abs_q(t, P->coeffs + p - i, P->coeffs + p); fmpz_root(t, t, i); fmpz_add_ui(t, t, 1); if (fmpz_cmp(t, A) > 0) fmpz_swap(t, A); } if (!fmpz_fits_si(A)) abort(); res = fmpz_get_si(A); fmpz_clear(A); fmpz_clear(t); return res; }
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); } }
int main() { slong iter; flint_rand_t state; flint_printf("add_ui_inline...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { fmpz_t a, c, d; ulong b; fmpz_init(a); fmpz_init(c); fmpz_init(d); fmpz_randtest(a, state, 1 + n_randint(state, 200)); fmpz_randtest(c, state, 1 + n_randint(state, 200)); fmpz_randtest(d, state, 1 + n_randint(state, 200)); b = n_randtest(state); fmpz_add_ui(c, a, b); fmpz_add_ui_inline(d, a, b); if (!fmpz_equal(c, d)) { flint_printf("FAIL\n"); fmpz_print(a); flint_printf("\n\n"); flint_printf("%wu", b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_add_ui_inline(a, a, b); if (!fmpz_equal(c, a)) { flint_printf("FAIL (aliasing)\n"); fmpz_print(a); flint_printf("\n\n"); flint_printf("%wu", b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(c); fmpz_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void bernoulli_rev_init(bernoulli_rev_t iter, ulong nmax) { long j; fmpz_t t; fmprb_t x; int round1, round2; long wp; nmax -= (nmax % 2); iter->n = nmax; iter->alloc = 0; if (nmax < BERNOULLI_REV_MIN) return; iter->prec = wp = global_prec(nmax); iter->max_power = zeta_terms(nmax, iter->prec); iter->alloc = iter->max_power + 1; iter->powers = _fmpz_vec_init(iter->alloc); fmpz_init(iter->pow_error); fmprb_init(iter->prefactor); fmprb_init(iter->two_pi_squared); fmprb_init(x); fmpz_init(t); /* precompute powers */ for (j = 3; j <= iter->max_power; j += 2) { fmprb_ui_pow_ui(x, j, nmax, power_prec(j, nmax, wp)); fmprb_ui_div(x, 1UL, x, power_prec(j, nmax, wp)); round1 = fmpr_get_fmpz_fixed_si(t, fmprb_midref(x), -wp); fmpz_set(iter->powers + j, t); /* error: the radius, plus two roundings */ round2 = fmpr_get_fmpz_fixed_si(t, fmprb_radref(x), -wp); fmpz_add_ui(t, t, (round1 != 0) + (round2 != 0)); if (fmpz_cmp(iter->pow_error, t) < 0) fmpz_set(iter->pow_error, t); } /* precompute (2pi)^2 and 2*(n!)/(2pi)^n */ fmprb_fac_ui(iter->prefactor, nmax, wp); fmprb_mul_2exp_si(iter->prefactor, iter->prefactor, 1); fmprb_const_pi(x, wp); fmprb_mul_2exp_si(x, x, 1); fmprb_mul(iter->two_pi_squared, x, x, wp); fmprb_pow_ui(x, iter->two_pi_squared, nmax / 2, wp); fmprb_div(iter->prefactor, iter->prefactor, x, wp); fmpz_clear(t); fmprb_clear(x); }
void fmprb_fac_ui(fmprb_t x, ulong n, long prec) { fmpz_t t; fmpz_init(t); fmpz_set_ui(t, n); fmpz_add_ui(t, t, 1); fmprb_gamma_fmpz(x, t, prec); fmpz_clear(t); }
int main() { slong iter; flint_rand_t state; flint_printf("bell_sum_taylor...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t s1, s2; fmpz_t a, b, n; slong prec; arb_init(s1); arb_init(s2); fmpz_init(a); fmpz_init(b); fmpz_init(n); prec = 2 + n_randint(state, 300); fmpz_randtest_unsigned(n, state, 1 + n_randint(state, 100)); fmpz_randtest_unsigned(a, state, 1 + n_randint(state, 100)); fmpz_add_ui(b, a, n_randint(state, 100)); arb_bell_sum_bsplit(s1, n, a, b, NULL, prec); arb_bell_sum_taylor(s2, n, a, b, NULL, prec); if (!arb_overlaps(s1, s2) || (arb_rel_accuracy_bits(s1) < prec - 4) || (arb_rel_accuracy_bits(s2) < prec - 4)) { flint_printf("FAIL: overlap or accuracy\n\n"); flint_printf("prec = %wd\n\n", prec); flint_printf("n = "); fmpz_print(n); flint_printf("\n\n"); flint_printf("a = "); fmpz_print(a); flint_printf("\n\n"); flint_printf("b = "); fmpz_print(b); flint_printf("\n\n"); flint_printf("s1 = "); arb_printn(s1, 100, 0); flint_printf("\n\n"); flint_printf("s2 = "); arb_printn(s2, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(s1); arb_clear(s2); fmpz_clear(a); fmpz_clear(b); fmpz_clear(n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void _fmprb_get_rand_fmpq(fmpz_t num, fmpz_t den, flint_rand_t state, const fmpz_t den_mult, const fmprb_t x) { fmpz_t a, b, exp; fmpz_init(a); fmpz_init(b); fmpz_init(exp); fmprb_get_interval_fmpz_2exp(a, b, exp, x); if (COEFF_IS_MPZ(*exp)) { printf("exception: fmprb_get_rand_fmpq: too large exponent\n"); abort(); } if (*exp >= 0) { fmpz_mul_2exp(a, a, *exp); fmpz_mul_2exp(b, b, *exp); } /* generate random integer in [a*den, b*den] */ fmpz_mul(a, a, den_mult); fmpz_mul(b, b, den_mult); fmpz_add_ui(b, b, 1UL); fmpz_sub(b, b, a); /* return one endpoint with high probability (used for stress testing rounding) */ if (n_randint(state, 6) == 0) { if (n_randint(state, 2)) fmpz_zero(num); else fmpz_sub_ui(num, b, 1UL); } else { fmpz_randtest_mod(num, state, b); } fmpz_add(num, num, a); fmpz_set(den, den_mult); if (*exp < 0) fmpz_mul_2exp(den, den, -(*exp)); fmpz_clear(a); fmpz_clear(b); fmpz_clear(exp); }
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 _padic_log_balanced(fmpz_t z, const fmpz_t y, long v, const fmpz_t p, long N) { fmpz_t pv, pN, r, t, u; long val; padic_inv_t S; fmpz_init(pv); fmpz_init(pN); fmpz_init(r); fmpz_init(t); fmpz_init(u); _padic_inv_precompute(S, p, N); fmpz_set(t, y); fmpz_set(pv, p); fmpz_pow_ui(pN, p, N); fmpz_zero(z); val = 1; /* TODO: Abort earlier if larger than $p^N$, possible with variable precision? */ while (!fmpz_is_zero(t)) { fmpz_mul(pv, pv, pv); fmpz_fdiv_qr(t, r, t, pv); if (!fmpz_is_zero(t)) { fmpz_mul(t, t, pv); fmpz_add_ui(u, r, 1); _padic_inv_precomp(u, u, S); fmpz_mul(t, t, u); fmpz_mod(t, t, pN); } if (!fmpz_is_zero(r)) { fmpz_neg(r, r); _padic_log_bsplit(r, r, val, p, N); fmpz_sub(z, z, r); } val *= 2; } fmpz_clear(pv); fmpz_clear(pN); fmpz_clear(r); fmpz_clear(t); fmpz_clear(u); _padic_inv_clear(S); }
int main(void) { long i; fmpz_t x; printf("fits_si...."); fflush(stdout); fmpz_init(x); fmpz_set_si(x, COEFF_MIN); check(x, 1); fmpz_set_si(x, COEFF_MAX); check(x, 1); fmpz_set_si(x, LONG_MAX); check(x, 1); fmpz_set_si(x, LONG_MIN); check(x, 1); fmpz_set_ui(x, ULONG_MAX); check(x, 0); fmpz_set_ui(x, ULONG_MAX); fmpz_neg(x, x); check(x, 0); fmpz_set_si(x, LONG_MAX); fmpz_add_ui(x, x, 1); check(x, 0); fmpz_set_si(x, LONG_MIN); fmpz_sub_ui(x, x, 1); check(x, 0); for (i = 0; i < 1000; i++) { fmpz_set_ui(x, 1); fmpz_mul_2exp(x, x, i); check(x, i < FLINT_BITS - 1); fmpz_neg(x, x); check(x, i < FLINT_BITS); /* LONG_MIN fits */ } fmpz_clear(x); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("swap...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, c; 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(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest(b, state, n_randint(state, 100)); fmpz_mod_poly_set(c, b); fmpz_mod_poly_swap(a, b); result = (fmpz_mod_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); fmpz_clear(p); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; printf("neg...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, c; 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(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_neg(b, a); fmpz_mod_poly_neg(c, b); result = (fmpz_mod_poly_equal(a, c)); if (!result) { printf("FAIL:\n"); fmpz_mod_poly_print(a), printf("\n\n"); fmpz_mod_poly_print(b), printf("\n\n"); fmpz_mod_poly_print(c), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); fmpz_clear(p); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
/* The floor+vec method *requires* n <= 1498 for floor(p(n)/2^64) to be equal to floor(T/2^64). It is faster up to n ~= 1200. With doubles, it is faster up to n ~= 500. */ void _partitions_fmpz_ui(fmpz_t res, ulong n, int use_doubles) { if (n < NUMBER_OF_SMALL_PARTITIONS) { fmpz_set_ui(res, partitions_lookup[n]); } else if (FLINT_BITS == 64 && (n < 500 || (!use_doubles && n < 1200))) { mp_ptr tmp = flint_malloc((n + 1) * sizeof(mp_limb_t)); if (n < 417) /* p(n) < 2^64 */ { partitions_vec(tmp, n + 1); fmpz_set_ui(res, tmp[n]); } else { arb_t x; arb_init(x); fmpz_set_ui(res, n); partitions_leading_fmpz(x, res, 4 * sqrt(n) - 50); arb_mul_2exp_si(x, x, -64); arb_floor(x, x, 4 * sqrt(n) - 50); if (arb_get_unique_fmpz(res, x)) { fmpz_mul_2exp(res, res, 64); partitions_vec(tmp, n + 1); fmpz_add_ui(res, res, tmp[n]); } else { flint_printf("warning: failed at %wu\n", n); fmpz_set_ui(res, n); partitions_fmpz_fmpz_hrr(res, res, use_doubles); } arb_clear(x); } flint_free(tmp); } else { fmpz_set_ui(res, n); partitions_fmpz_fmpz_hrr(res, res, use_doubles); } }
int arf_add_fmpz_2exp(arf_ptr z, arf_srcptr x, const fmpz_t y, const fmpz_t exp, slong prec, arf_rnd_t rnd) { mp_size_t xn, yn; mp_srcptr xptr, yptr; mp_limb_t ytmp; int xsgnbit, ysgnbit, inexact; fmpz_t yexp; slong shift; if (fmpz_is_zero(y)) { return arf_set_round(z, x, prec, rnd); } else if (arf_is_special(x)) { if (arf_is_zero(x)) { inexact = arf_set_round_fmpz(z, y, prec, rnd); arf_mul_2exp_fmpz(z, z, exp); return inexact; } else { arf_set(z, x); return 0; } } FMPZ_GET_MPN_READONLY(ysgnbit, yn, yptr, ytmp, *y) fmpz_init(yexp); fmpz_add_ui(yexp, exp, yn * FLINT_BITS); shift = _fmpz_sub_small(ARF_EXPREF(x), yexp); xsgnbit = ARF_SGNBIT(x); ARF_GET_MPN_READONLY(xptr, xn, x); if (shift >= 0) inexact = _arf_add_mpn(z, xptr, xn, xsgnbit, ARF_EXPREF(x), yptr, yn, ysgnbit, shift, prec, rnd); else inexact = _arf_add_mpn(z, yptr, yn, ysgnbit, yexp, xptr, xn, xsgnbit, -shift, prec, rnd); fmpz_clear(yexp); return inexact; }
int main(void) { long i; fmpz_t x; printf("abs_fits_ui...."); fflush(stdout); fmpz_init(x); fmpz_set_si(x, COEFF_MIN); check(x, 1); fmpz_set_si(x, COEFF_MAX); check(x, 1); fmpz_set_ui(x, ULONG_MAX); check(x, 1); fmpz_set_ui(x, ULONG_MAX); fmpz_neg(x, x); check(x, 1); fmpz_set_ui(x, ULONG_MAX); fmpz_add_ui(x, x, 1UL); check(x, 0); fmpz_neg(x, x); check(x, 0); for (i = 0; i < 1000; i++) { fmpz_set_ui(x, 1UL); fmpz_mul_2exp(x, x, i); check(x, i < FLINT_BITS); fmpz_neg(x, x); check(x, i < FLINT_BITS); } fmpz_clear(x); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int dgsl_rot_mp_call_plus1(fmpz_poly_t rop, const dgsl_rot_mp_t *self, gmp_randstate_t state) { const long n = self->n; fmpq_poly_t x; fmpq_poly_init(x); fmpq_poly_sample_D1(x, n, self->prec, state); fmpq_poly_oz_mul(x, self->sigma_sqrt, x, self->n); fmpq_poly_neg(x, x); // (-x2) // we sample with centre c = -1/g fmpq_poly_sub(x, x, self->B_inv); // (c+x2) fmpz_poly_disc_gauss_rounding(rop, x, self->r_f, state); fmpz_poly_neg(rop, rop); fmpz_poly_oz_mul(rop, self->B, rop, self->n); fmpz_add_ui(rop->coeffs, rop->coeffs, 1); fmpq_poly_clear(x); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("zero...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a; 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_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_zero(a); result = (fmpz_mod_poly_is_zero(a)); if (!result) { flint_printf("FAIL:\n"); flint_printf("a = "), fmpz_mod_poly_print(a), flint_printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_clear(p); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
void fmpz_mat_randajtai(fmpz_mat_t mat, flint_rand_t state, double alpha) { long r, c, i, j, d; fmpz_t tmp; r = mat->r; c = mat->c; d = r; if (c != r) { printf("Exception: fmpz_mat_ajtai called on an ill-formed matrix\n"); abort(); } fmpz_init(tmp); for (i = 0; i < d; i++) { mp_bitcnt_t bits = (mp_bitcnt_t) pow((double) (2 * d - i), alpha); fmpz_one(tmp); fmpz_mul_2exp(tmp, tmp, bits); fmpz_sub_ui(tmp, tmp, 1); fmpz_randm(mat->rows[i] + i, state, tmp); fmpz_add_ui(mat->rows[i] + i, mat->rows[i] + i, 2); fmpz_fdiv_q_2exp(mat->rows[i] + i, mat->rows[i] + i, 1); for (j = i + 1; j <= d; j++) { fmpz_randm(mat->rows[j] + i, state, tmp); if (n_randint(state, 2)) fmpz_neg(mat->rows[j] + i, mat->rows[j] + i); fmpz_zero(mat->rows[i] + j); } } fmpz_clear(tmp); }
void fmpz_mat_randajtai(fmpz_mat_t mat, flint_rand_t state, double alpha) { const slong c = mat->c, r = mat->r, d = r; slong i, j; fmpz_t tmp; if (c != r) { flint_printf("Exception (fmpz_mat_ajtai): Non-square matrix.\n"); abort(); } fmpz_init(tmp); for (i = 0; i < d; i++) { mp_bitcnt_t bits = (mp_bitcnt_t) pow((double) (2 * d - i), alpha); fmpz_one(tmp); fmpz_mul_2exp(tmp, tmp, bits); fmpz_sub_ui(tmp, tmp, 1); fmpz_randm(mat->rows[i] + i, state, tmp); fmpz_add_ui(mat->rows[i] + i, mat->rows[i] + i, 2); fmpz_fdiv_q_2exp(mat->rows[i] + i, mat->rows[i] + i, 1); for (j = i + 1; j <= d; j++) { fmpz_randm(mat->rows[j] + i, state, tmp); if (n_randint(state, 2)) fmpz_neg(mat->rows[j] + i, mat->rows[j] + i); fmpz_zero(mat->rows[i] + j); } } fmpz_clear(tmp); }
void test0(slong b) { fmpz_t M; fmpz_init_set_ui(M,1); fmpz_mul_2exp(M,M,(ulong)b); test1_ui(b,M,0); test1_ui(b,M,1); test1_ui(b,M,(mp_limb_t)-1); test1(b,M,M); // M fmpz_t n; fmpz_init_set(n,M); fmpz_add_ui(n,M,1); test1(b,M,n); // M+1 fmpz_sub_ui(n,M,1); test1(b,M,n); // M-1 slong i; fmpz_t m; fmpz_init(m); fmpz_t Mhalf; fmpz_init(Mhalf); fmpz_fdiv_q_2exp(Mhalf,M,1); for(i=100;i--;) { fmpz_randm(m,rst,n); // m = random(M-1) test1(b,M,m); fmpz_add(m,m,Mhalf); // m+M/2 test1(b,M,m); } fmpz_mul_2exp(m,M,1); test1(b,M,m); // M<<1 fmpz_mul_2exp(m,m,1); test1(b,M,m); // M<<2 fmpz_mul_2exp(m,m,1); test1(b,M,m); // M<<3 fmpz_mul(m,m,M); test1(b,M,m); // M*(M<<3) fmpz_clear(Mhalf); fmpz_clear(m); fmpz_clear(n); fmpz_clear(M); }
void _arb_poly_get_scale(fmpz_t scale, arb_srcptr x, slong xlen, arb_srcptr y, slong ylen) { slong xa, xb, ya, yb, den; fmpz_zero(scale); /* ignore zeros (and infs/nans!); find the first and last finite nonzero entries to determine the scale */ xa = 0; xb = xlen - 1; while (xa < xlen && arf_is_special(arb_midref(x + xa))) xa++; while (xb > xa && arf_is_special(arb_midref(x + xb))) xb--; ya = 0; yb = ylen - 1; while (ya < ylen && arf_is_special(arb_midref(y + ya))) ya++; while (yb > ya && arf_is_special(arb_midref(y + yb))) yb--; /* compute average of exponent differences, weighted by the lengths */ if (xa <= xb && ya <= yb && (xa < xb || ya < yb)) { fmpz_add(scale, scale, ARF_EXPREF(arb_midref(x + xb))); fmpz_sub(scale, scale, ARF_EXPREF(arb_midref(x + xa))); fmpz_add(scale, scale, ARF_EXPREF(arb_midref(y + yb))); fmpz_sub(scale, scale, ARF_EXPREF(arb_midref(y + ya))); den = (xb - xa) + (yb - ya); /* scale = floor(scale / den + 1/2) = floor((2 scale + den) / (2 den)) */ fmpz_mul_2exp(scale, scale, 1); fmpz_add_ui(scale, scale, den); fmpz_fdiv_q_ui(scale, scale, 2 * den); } }
void fmpz_mat_solve_bound(fmpz_t N, fmpz_t D, const fmpz_mat_t A, const fmpz_mat_t B) { slong i, j, m, n; fmpz_t t, u; m = B->r; n = B->c; fmpz_mat_det_bound(D, A); fmpz_init(t); fmpz_init(u); fmpz_zero(t); /* Largest column norm of B */ for (j = 0; j < n; j++) { fmpz_zero(u); for (i = 0; i < m; i++) fmpz_addmul(u, fmpz_mat_entry(B, i, j), fmpz_mat_entry(B, i, j)); if (fmpz_cmp(t, u) < 0) fmpz_set(t, u); } fmpz_sqrtrem(t, u, t); if (!fmpz_is_zero(u)) fmpz_add_ui(t, t, UWORD(1)); fmpz_mul(N, D, t); fmpz_clear(t); fmpz_clear(u); }
/* atan(x) = pi/2 - eps, eps < 1/x <= 2^(1-mag) */ void arb_atan_inf_eps(arb_t z, const arf_t x, slong prec) { fmpz_t mag; fmpz_init(mag); fmpz_neg(mag, ARF_EXPREF(x)); fmpz_add_ui(mag, mag, 1); if (arf_sgn(x) > 0) { arb_const_pi(z, prec); } else { arb_const_pi(z, prec); arb_neg(z, z); } arb_mul_2exp_si(z, z, -1); arb_add_error_2exp_fmpz(z, mag); fmpz_clear(mag); }
static __inline__ void _arb_poly_addmullow_rad(arb_ptr z, fmpz * zz, const fmpz * xz, const double * xdbl, const fmpz * xexps, const slong * xblocks, slong xlen, const fmpz * yz, const double * ydbl, const fmpz * yexps, const slong * yblocks, slong ylen, slong n) { slong i, j, k, ii, xp, yp, xl, yl, bn; fmpz_t zexp; mag_t t; fmpz_init(zexp); mag_init(t); for (i = 0; (xp = xblocks[i]) != xlen; i++) { for (j = 0; (yp = yblocks[j]) != ylen; j++) { if (xp + yp >= n) continue; xl = xblocks[i + 1] - xp; yl = yblocks[j + 1] - yp; bn = FLINT_MIN(xl + yl - 1, n - xp - yp); xl = FLINT_MIN(xl, bn); yl = FLINT_MIN(yl, bn); fmpz_add_inline(zexp, xexps + i, yexps + j); if (xl > 1 && yl > 1 && (xl < DOUBLE_BLOCK_MAX_LENGTH || yl < DOUBLE_BLOCK_MAX_LENGTH)) { fmpz_add_ui(zexp, zexp, 2 * DOUBLE_BLOCK_SHIFT); for (k = 0; k < bn; k++) { /* Classical multiplication (may round down!) */ double ss = 0.0; for (ii = FLINT_MAX(0, k - yl + 1); ii <= FLINT_MIN(xl - 1, k); ii++) { ss += xdbl[xp + ii] * ydbl[yp + k - ii]; } /* Compensate for rounding error */ ss *= DOUBLE_ROUNDING_FACTOR; mag_set_d_2exp_fmpz(t, ss, zexp); mag_add(arb_radref(z + xp + yp + k), arb_radref(z + xp + yp + k), t); } } else { if (xl >= yl) _fmpz_poly_mullow(zz, xz + xp, xl, yz + yp, yl, bn); else _fmpz_poly_mullow(zz, yz + yp, yl, xz + xp, xl, bn); for (k = 0; k < bn; k++) { mag_set_fmpz_2exp_fmpz(t, zz + k, zexp); mag_add(arb_radref(z + xp + yp + k), arb_radref(z + xp + yp + k), t); } } } } fmpz_clear(zexp); mag_clear(t); }
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, result; FLINT_TEST_INIT(state); flint_printf("pow_trunc...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 10000; i++) { fmpz_mod_poly_t a, b, c; fmpz_t p; slong e, trunc; 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(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 30)); e = n_randint(state, 20); trunc = n_randint(state, 30); fmpz_mod_poly_set(c, a); fmpz_mod_poly_pow_trunc(b, a, e, trunc); fmpz_mod_poly_pow_trunc(c, c, e, trunc); result = (fmpz_mod_poly_equal(b, c)); if (!result) { flint_printf("FAIL aliasing:\n"); flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n", a->length, a->p, e, trunc); flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_clear(p); fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); } /* Check powering against naive method */ for (i = 0; i < 10000; i++) { fmpz_mod_poly_t a, b, c; fmpz_t p; slong e, trunc; 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(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 30)); e = n_randint(state, 20); trunc = n_randint(state, 30); fmpz_mod_poly_pow_trunc(b, a, e, trunc); fmpz_mod_poly_pow(c, a, e); fmpz_mod_poly_truncate(c, trunc); result = (fmpz_mod_poly_equal(b, c) || (a->length == 0 && e == 0 && c->length == 1 && c->coeffs[0] == 1)); if (!result) { flint_printf("FAIL:\n"); flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n", a->length, a->p, e, trunc); flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_clear(p); fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
void arf_get_fmpz(fmpz_t z, const arf_t x, arf_rnd_t rnd) { if (arf_is_special(x)) { if (arf_is_zero(x)) { fmpz_zero(z); } else { flint_printf("arf_get_fmpz: cannot convert infinity or nan to integer\n"); abort(); } } else if (COEFF_IS_MPZ(*ARF_EXPREF(x))) { /* tiny */ if (fmpz_sgn(ARF_EXPREF(x)) < 0) { int negative = ARF_SGNBIT(x); if (rnd == ARF_RND_NEAR || rnd == ARF_RND_DOWN || (rnd == ARF_RND_FLOOR && !negative) || (rnd == ARF_RND_CEIL && negative)) { fmpz_zero(z); } else { fmpz_set_si(z, negative ? -1 : 1); } } else { flint_printf("arf_get_fmpz: number too large to convert to integer\n"); abort(); } } else { slong exp; int negative, inexact; mp_size_t xn, zn; mp_srcptr xp; __mpz_struct * zz; /* TBD: implement efficiently */ if (rnd == ARF_RND_NEAR) { fmpr_t t; fmpr_init(t); arf_get_fmpr(t, x); fmpr_get_fmpz(z, t, rnd); fmpr_clear(t); return; } exp = ARF_EXP(x); negative = ARF_SGNBIT(x); /* |x| < 1 */ if (exp <= 0) { if (rnd == ARF_RND_DOWN || (rnd == ARF_RND_FLOOR && !negative) || (rnd == ARF_RND_CEIL && negative)) { fmpz_zero(z); } else { fmpz_set_si(z, negative ? -1 : 1); } return; } ARF_GET_MPN_READONLY(xp, xn, x); /* |x| < 2^31 or 2^63 (must save 1 bit for rounding up!) */ if (exp < FLINT_BITS) { mp_limb_t v, v2; v = xp[xn - 1]; v2 = v >> (FLINT_BITS - exp); inexact = (xn > 1) || ((v2 << (FLINT_BITS - exp)) != v); if (inexact && rnd != ARF_RND_DOWN) { if (negative && (rnd == ARF_RND_UP || rnd == ARF_RND_FLOOR)) v2++; if (!negative && (rnd == ARF_RND_UP || rnd == ARF_RND_CEIL)) v2++; } if (negative) fmpz_neg_ui(z, v2); else fmpz_set_ui(z, v2); return; } /* |x| >= 1 */ zn = (exp + FLINT_BITS - 1) / FLINT_BITS; zz = _fmpz_promote(z); if (zz->_mp_alloc < zn) mpz_realloc2(zz, zn * FLINT_BITS); inexact = _arf_get_integer_mpn(zz->_mp_d, xp, xn, exp); zz->_mp_size = negative ? -zn : zn; _fmpz_demote_val(z); if (inexact && rnd != ARF_RND_DOWN) { if (negative && (rnd == ARF_RND_UP || rnd == ARF_RND_FLOOR)) fmpz_sub_ui(z, z, 1); if (!negative && (rnd == ARF_RND_UP || rnd == ARF_RND_CEIL)) fmpz_add_ui(z, z, 1); } }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_nzeros_gram...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 130 + 20 * arb_test_multiplier(); iter++) { arb_t t, x; fmpz_t N, n; slong prec1, prec2; arb_init(t); arb_init(x); fmpz_init(n); fmpz_init(N); if (iter < 130) { fmpz_set_si(n, iter - 1); } else { fmpz_randtest_unsigned(n, state, 20); fmpz_add_ui(n, n, 129); } prec1 = 2 + n_randtest(state) % 100; prec2 = 2 + n_randtest(state) % 100; acb_dirichlet_zeta_nzeros_gram(N, n); acb_dirichlet_gram_point(t, n, NULL, NULL, prec1); acb_dirichlet_zeta_nzeros(x, t, prec2); if (!arb_contains_fmpz(x, N)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = "); fmpz_print(n); flint_printf(" prec1 = %wd prec2 = %wd\n\n", prec1, prec2); flint_printf("N = "); fmpz_print(N); flint_printf("\n\n"); flint_printf("t = "); arb_printn(t, 100, 0); flint_printf("\n\n"); flint_printf("x = "); arb_printn(x, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(t); arb_clear(x); fmpz_clear(n); fmpz_clear(N); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }