int fmpr_get_mpfr(mpfr_t x, const fmpr_t y, mpfr_rnd_t rnd) { int r; if (fmpr_is_special(y)) { if (fmpr_is_zero(y)) mpfr_set_zero(x, 0); else if (fmpr_is_pos_inf(y)) mpfr_set_inf(x, 1); else if (fmpr_is_neg_inf(y)) mpfr_set_inf(x, -1); else mpfr_set_nan(x); r = 0; } else if (COEFF_IS_MPZ(*fmpr_expref(y))) { flint_printf("exception: exponent too large to convert to mpfr"); abort(); } else { if (!COEFF_IS_MPZ(*fmpr_manref(y))) #if defined(__MINGW64__) r = mpfr_set_sj_2exp(x, *fmpr_manref(y), *fmpr_expref(y), rnd); #else r = mpfr_set_si_2exp(x, *fmpr_manref(y), *fmpr_expref(y), rnd); #endif else r = mpfr_set_z_2exp(x, COEFF_TO_PTR(*fmpr_manref(y)), *fmpr_expref(y), rnd); if (!mpfr_regular_p(x)) { flint_printf("exception: exponent too large to convert to mpfr"); abort(); } }
int fmpq_get_mpfr(mpfr_t r, const fmpq_t x, mpfr_rnd_t rnd) { __mpq_struct mpq; fmpz p, q; mp_limb_t pp, qq; p = *fmpq_numref(x); q = *fmpq_denref(x); if (p == 0) return mpfr_set_ui(r, 0, rnd); if (COEFF_IS_MPZ(p)) mpq._mp_num = *COEFF_TO_PTR(p); else { pp = FLINT_ABS(p); mpq._mp_num._mp_alloc = 1; mpq._mp_num._mp_size = (p < 0) ? -1 : 1; mpq._mp_num._mp_d = &pp; } if (COEFF_IS_MPZ(q)) mpq._mp_den = *COEFF_TO_PTR(q); else { qq = q; mpq._mp_den._mp_alloc = 1; mpq._mp_den._mp_size = 1; mpq._mp_den._mp_d = &qq; } return mpfr_set_q(r, &mpq, rnd); }
void fmpz_tdiv_qr(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h) { fmpz c1 = *g; fmpz c2 = *h; if (fmpz_is_zero(h)) { flint_printf("Exception: division by zero in fmpz_tdiv_qr\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 */ fmpz_set_si(f, q); fmpz_set_si(s, r); } else /* h is large and g is small */ { fmpz_set_ui(f, WORD(0)); /* g is zero */ fmpz_set_si(s, c1); } } else /* g is large */ { __mpz_struct *mpz_ptr, *mpz_ptr2; _fmpz_promote(f); /* must not hang on to ptr whilst promoting s */ mpz_ptr2 = _fmpz_promote(s); mpz_ptr = COEFF_TO_PTR(*f); if (!COEFF_IS_MPZ(c2)) /* h is small */ { if (c2 > 0) /* h > 0 */ { flint_mpz_tdiv_qr_ui(mpz_ptr, mpz_ptr2, COEFF_TO_PTR(c1), c2); } else { flint_mpz_tdiv_qr_ui(mpz_ptr, mpz_ptr2, COEFF_TO_PTR(c1), -c2); mpz_neg(mpz_ptr, mpz_ptr); } } else /* both are large */ { mpz_tdiv_qr(mpz_ptr, mpz_ptr2, COEFF_TO_PTR(c1), COEFF_TO_PTR(c2)); } _fmpz_demote_val(f); /* division by h may result in small value */ _fmpz_demote_val(s); /* division by h may result in small value */ } }
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); } } } }
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 */ } }
void mag_sqrt(mag_t y, const mag_t x) { if (mag_is_special(x)) { mag_set(y, x); } else { double t; fmpz e; t = MAG_MAN(x) * ldexp(1.0, -MAG_BITS); e = MAG_EXP(x); if (!COEFF_IS_MPZ(e)) { if (e % 2 != 0) { e = (e - 1) >> 1; t *= 2.0; } else { e >>= 1; } t = sqrt(t) * (1 + 1e-13); mag_set_d_2exp_fmpz(y, t, &e); }
void fmpr_get_fmpq(fmpq_t y, const fmpr_t x) { if (fmpr_is_zero(x)) { fmpq_zero(y); } else if (fmpr_is_special(x) || COEFF_IS_MPZ(*fmpr_expref(x))) { printf("exception: fmpr_get_fmpq: cannot convert to rational\n"); abort(); } else { long exp = *fmpr_expref(x); fmpz_set_ui(fmpq_denref(y), 1UL); if (exp >= 0) { fmpz_mul_2exp(fmpq_numref(y), fmpr_manref(x), exp); } else { fmpz_set(fmpq_numref(y), fmpr_manref(x)); fmpz_mul_2exp(fmpq_denref(y), fmpq_denref(y), -exp); } } }
int fmpz_fprint(FILE * file, const fmpz_t x) { if (!COEFF_IS_MPZ(*x)) return fprintf(file, "%ld", *x); else return (int) mpz_out_str(file, 10, COEFF_TO_PTR(*x)); }
void arf_ceil(arf_t z, const arf_t x) { if (arf_is_special(x) || arf_is_int(x)) { arf_set(z, x); } else { slong exp = ARF_EXP(x); /* now exp cannot be too large, as we would have caught this in arf_is_int() */ if (COEFF_IS_MPZ(exp) || exp <= 0) { if (ARF_SGNBIT(x)) arf_zero(z); else arf_one(z); } else if (exp == 1) { arf_set_si(z, ARF_SGNBIT(x) ? -1 : 2); } else { arf_set_round(z, x, exp, ARF_RND_CEIL); } } }
static int use_algebraic(const fmpz_t v, const fmpz_t w, slong prec) { fmpz q = *w; int r; if (COEFF_IS_MPZ(q)) return 0; if (q <= 6) return 1; count_trailing_zeros(r, q); q >>= r; if (r >= 4 && prec < (r - 3) * 300) return 0; if (q > 1000) return 0; if (prec < 1500 + 150 * q) return 0; return 1; }
ulong fmpz_fdiv_ui(const fmpz_t g, ulong h) { fmpz c1 = *g; ulong r; if (h == 0UL) { printf("Exception: division by 0 in fmpz_fdiv_ui\n"); abort(); } if (!COEFF_IS_MPZ(c1)) /* g is small */ { if (c1 < 0L) { r = h - (-c1 % h); /* C doesn't correctly handle negative mods */ if (r == h) r = 0; } else r = c1 % h; return r; } else /* g is large */ { return mpz_fdiv_ui(COEFF_TO_PTR(c1), h); } }
void fmpz_tdiv_q_ui(fmpz_t f, const fmpz_t g, ulong h) { fmpz c1 = *g; ulong c2 = h; if (h == 0) { printf("Exception: division by zero in fmpz_tdiv_q_ui\n"); abort(); } if (!COEFF_IS_MPZ(c1)) /* g is small */ { if (c1 > 0) { fmpz_set_ui(f, c1 / c2); } else { ulong q = ((ulong) -c1) / c2; fmpz_set_si(f, - (long) q); } } else /* g is large */ { __mpz_struct *mpz_ptr = _fmpz_promote(f); mpz_tdiv_q_ui(mpz_ptr, COEFF_TO_PTR(c1), c2); _fmpz_demote_val(f); /* division by h may result in small value */ } }
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 fmpz_gcd(fmpz_t f, const fmpz_t g, const fmpz_t h) { fmpz c1 = *g; fmpz c2 = *h; if (fmpz_is_zero(g)) { fmpz_abs(f, h); return; } if (fmpz_is_zero(h)) { fmpz_abs(f, g); return; } if (!COEFF_IS_MPZ(c1)) /* g is small */ { if (!COEFF_IS_MPZ(c2)) /* h is also small */ { fmpz_set_si(f, z_gcd(c1, c2)); } else /* h is large, but g is small */ { fmpz c2d = fmpz_fdiv_ui(h, FLINT_ABS(c1)); fmpz_set_si(f, z_gcd(c1, c2d)); } } else { if (!COEFF_IS_MPZ(c2)) /* h is small, but g is large */ { fmpz c1d = fmpz_fdiv_ui(g, FLINT_ABS(c2)); fmpz_set_si(f, z_gcd(c2, c1d)); } else /* g and h are both large */ { __mpz_struct *mpz_ptr = _fmpz_promote(f); /* aliasing fine as g, h already large */ mpz_gcd(mpz_ptr, COEFF_TO_PTR(c1), COEFF_TO_PTR(c2)); _fmpz_demote_val(f); /* gcd may be small */ } } }
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); }
static __inline__ void fmpz_clear_and_zero(fmpz_t f) // works like fmpz_zero(), but does not assign zero twice --- one time // is quite enough { if (COEFF_IS_MPZ(*f)) _fmpz_clear_mpz(*f); (*f) = WORD(0); }
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); }
void fmpz_divexact(fmpz_t f, const fmpz_t g, const fmpz_t h) { fmpz c1 = *g; fmpz c2 = *h; if (fmpz_is_zero(h)) { flint_printf("Exception (fmpz_divexact). Division by zero.\n"); abort(); } if (!COEFF_IS_MPZ(c1)) /* g is small, h must be also or division isn't exact */ { fmpz_set_si(f, c1 / c2); } else /* g is large */ { __mpz_struct * mpz_ptr = _fmpz_promote(f); if (!COEFF_IS_MPZ(c2)) /* h is small */ { if (c2 > 0) /* h > 0 */ { flint_mpz_divexact_ui(mpz_ptr, COEFF_TO_PTR(c1), c2); _fmpz_demote_val(f); /* division by h may result in small value */ } else { flint_mpz_divexact_ui(mpz_ptr, COEFF_TO_PTR(c1), -c2); _fmpz_demote_val(f); /* division by h may result in small value */ fmpz_neg(f, f); } } else /* both are large */ { mpz_divexact(mpz_ptr, COEFF_TO_PTR(c1), COEFF_TO_PTR(c2)); _fmpz_demote_val(f); /* division by h may result in small value */ } } }
int fmpz_fits_si(const fmpz_t f) { if (!COEFF_IS_MPZ(*f)) { return 1; } else { return mpz_fits_slong_p(COEFF_TO_PTR(*f)); } }
void flint_mpz_init_set_readonly(mpz_t z, const fmpz_t f) { if (COEFF_IS_MPZ(*f)) { *z = *COEFF_TO_PTR(*f); } else { mpz_init_set_si(z, *f); } }
__mpz_struct * _fmpz_promote(fmpz_t f) { if (!COEFF_IS_MPZ(*f)) /* f is small so promote it first */ { __mpz_struct * mpz_ptr = _fmpz_new_mpz(); (*f) = PTR_TO_COEFF(mpz_ptr); return mpz_ptr; } else /* f is large already, just return the pointer */ return COEFF_TO_PTR(*f); }
int fmpz_cmpabs(const fmpz_t f, const fmpz_t g) { if (f == g) return 0; /* aliased inputs */ if (!COEFF_IS_MPZ(*f)) { if (!COEFF_IS_MPZ(*g)) { mp_limb_t uf = FLINT_ABS(*f); mp_limb_t ug = FLINT_ABS(*g); return (uf < ug ? -1 : (uf > ug)); } else return -1; } else { if (!COEFF_IS_MPZ(*g)) return 1; /* f is large, so if g isn't... */ else return mpz_cmpabs(COEFF_TO_PTR(*f), COEFF_TO_PTR(*g)); } }
mp_size_t fmpz_size(const fmpz_t f) { fmpz d = *f; if (d == 0) return 0; if (!COEFF_IS_MPZ(d)) return 1; else return mpz_size(COEFF_TO_PTR(d)); }
void fmpz_neg_1arg( fmpz_t v ) // inspired by FLINT fmpz_neg { if (!COEFF_IS_MPZ(*v)) *v = -*v; else { __mpz_struct* mpz_ptr = _fmpz_promote(v); // TODO: write effective subroutine to invert GMP mpz in-place mpz_neg(mpz_ptr, mpz_ptr); } }
static __inline__ int low_bits_are_zero(const fmpz_t u, int bits) { fmpz f = *u; mp_limb_t low; if (!COEFF_IS_MPZ(f)) low = FLINT_ABS(f); else low = COEFF_TO_PTR(f)->_mp_d[0]; return (low & ((UWORD(1) << bits) - 1)) == 0; }
void fmpz_add(fmpz_t f, const fmpz_t g, const fmpz_t h) { fmpz c1 = *g; fmpz c2 = *h; if (!COEFF_IS_MPZ(c1)) /* g is small */ { if (!COEFF_IS_MPZ(c2)) /* both inputs are small */ { fmpz_set_si(f, c1 + c2); } else /* g is small, h is large */ { __mpz_struct * mpz3 = _fmpz_promote(f); /* g is saved and h is large */ __mpz_struct * mpz2 = COEFF_TO_PTR(c2); if (c1 < 0L) mpz_sub_ui(mpz3, mpz2, -c1); else mpz_add_ui(mpz3, mpz2, c1); _fmpz_demote_val(f); /* may have cancelled */ } } else { if (!COEFF_IS_MPZ(c2)) /* g is large, h is small */ { __mpz_struct * mpz3 = _fmpz_promote(f); /* h is saved and g is large */ __mpz_struct * mpz1 = COEFF_TO_PTR(c1); if (c2 < 0L) mpz_sub_ui(mpz3, mpz1, -c2); else mpz_add_ui(mpz3, mpz1, c2); _fmpz_demote_val(f); /* may have cancelled */ } else /* g and h are large */ { __mpz_struct * mpz3 = _fmpz_promote(f); /* aliasing means f is already large */ __mpz_struct * mpz1 = COEFF_TO_PTR(c1); __mpz_struct * mpz2 = COEFF_TO_PTR(c2); mpz_add(mpz3, mpz1, mpz2); _fmpz_demote_val(f); /* may have cancelled */ } } }
__mpz_struct * _fmpz_promote_val(fmpz_t f) { fmpz c = (*f); if (!COEFF_IS_MPZ(c)) /* f is small so promote it */ { __mpz_struct * mpz_ptr = _fmpz_new_mpz(); (*f) = PTR_TO_COEFF(mpz_ptr); mpz_set_si(mpz_ptr, c); return mpz_ptr; } else /* f is large already, just return the pointer */ return COEFF_TO_PTR(c); }
int fmpz_cmp_ui(const fmpz_t f, ulong g) { fmpz c = *f; if (!COEFF_IS_MPZ(c)) /* f is small */ { if (c < 0L || g > COEFF_MAX) return -1; else return c < (long) g ? -1 : c > (long) g; } else /* f is large */ return mpz_cmp_ui(COEFF_TO_PTR(c), g); }
int fmpz_fits_si(const fmpz_t f) { if (!COEFF_IS_MPZ(*f)) { return 1; } else { #if defined(_WIN64) return flint_mpz_fits_si_p(COEFF_TO_PTR(*f)); #else return mpz_fits_slong_p(COEFF_TO_PTR(*f)); #endif } }
void fmpz_sub_ui(fmpz_t f, const fmpz_t g, ulong x) { fmpz c = *g; if (!COEFF_IS_MPZ(c)) /* coeff is small */ { mp_limb_t sum[2]; if (c < 0L) /* g negative, x positive, so difference is negative */ { add_ssaaaa(sum[1], sum[0], 0, -c, 0, x); if (sum[1] == 0) { fmpz_set_ui(f, sum[0]); /* result fits in 1 limb */ fmpz_neg(f, f); } else /* result takes two limbs */ { __mpz_struct * mpz_ptr; mpz_t temp; temp->_mp_d = sum; temp->_mp_size = -2; /* result is negative number minus negative number, hence negative */ mpz_ptr = _fmpz_promote(f); /* g has already been read */ mpz_set(mpz_ptr, temp); } } else /* coeff is non-negative, x non-negative */ { if (x < c) fmpz_set_ui(f, c - x); /* won't be negative and is smaller than c */ else { fmpz_set_ui(f, x - c); /* positive or zero */ fmpz_neg(f, f); } } } else { __mpz_struct *mpz_ptr, *mpz_ptr2; mpz_ptr = COEFF_TO_PTR(c); mpz_ptr2 = _fmpz_promote(f); /* g is already large */ mpz_sub_ui(mpz_ptr2, mpz_ptr, x); _fmpz_demote_val(f); /* cancellation may have occurred */ } }