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