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); }
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 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); } }
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; }
void _arith_euler_number_zeta(fmpz_t res, ulong n) { mpz_t r; mpfr_t t, z, pi; mp_bitcnt_t prec, pi_prec; if (n % 2) { fmpz_zero(res); return; } if (n < SMALL_EULER_LIMIT) { fmpz_set_ui(res, euler_number_small[n / 2]); if (n % 4 == 2) fmpz_neg(res, res); return; } prec = arith_euler_number_size(n) + 10; pi_prec = prec + FLINT_BIT_COUNT(n); mpz_init(r); mpfr_init2(t, prec); mpfr_init2(z, prec); mpfr_init2(pi, pi_prec); flint_mpz_fac_ui(r, n); mpfr_set_z(t, r, GMP_RNDN); mpfr_mul_2exp(t, t, n + 2, GMP_RNDN); /* pi^(n + 1) * L(n+1) */ mpfr_zeta_inv_euler_product(z, n + 1, 1); mpfr_const_pi(pi, GMP_RNDN); mpfr_pow_ui(pi, pi, n + 1, GMP_RNDN); mpfr_mul(z, z, pi, GMP_RNDN); mpfr_div(t, t, z, GMP_RNDN); /* round */ mpfr_round(t, t); mpfr_get_z(r, t, GMP_RNDN); fmpz_set_mpz(res, r); if (n % 4 == 2) fmpz_neg(res, res); mpz_clear(r); mpfr_clear(t); mpfr_clear(z); mpfr_clear(pi); }
void _fmpz_mat_inv_2x2(fmpz ** b, fmpz_t den, fmpz ** const a) { fmpz_t tmp; _fmpz_mat_det_cofactor_2x2(den, a); fmpz_neg(&b[0][1], &a[0][1]); fmpz_neg(&b[1][0], &a[1][0]); fmpz_init(tmp); fmpz_set(tmp, &a[0][0]); fmpz_set(&b[0][0], &a[1][1]); fmpz_set(&b[1][1], tmp); fmpz_clear(tmp); }
void _fmpz_vec_neg(fmpz * vec1, const fmpz * vec2, long len2) { long i; for (i = 0; i < len2; i++) fmpz_neg(vec1 + i, vec2 + i); }
void _fmpz_holonomic_bsplit_hypgeom_fmpz(fmpz_t P, fmpz_t Q, const fmpz_poly_t R0, const fmpz_poly_t R1, long start, long a, long b) { if (b - a == 1) { fmpz c = start + a; fmpz_poly_evaluate_fmpz(P, R0, &c); fmpz_poly_evaluate_fmpz(Q, R1, &c); fmpz_neg(P, P); } else { fmpz_t P2, Q2; long m = a + (b - a) / 2; fmpz_init(P2); fmpz_init(Q2); _fmpz_holonomic_bsplit_hypgeom_fmpz(P, Q, R0, R1, start, a, m); _fmpz_holonomic_bsplit_hypgeom_fmpz(P2, Q2, R0, R1, start, m, b); fmpz_mul(P, P, P2); fmpz_mul(Q, Q, Q2); fmpz_clear(P2); fmpz_clear(Q2); } }
void _fmpz_holonomic_eval_companion_matrix_fmpz(fmpz_mat_t M, fmpz_t Q, const fmpz_holonomic_t op, long n) { fmpz_t c; long r = fmpz_holonomic_order(op); long i, j; fmpz_init(c); fmpz_set_si(c, n); fmpz_poly_evaluate_fmpz(Q, op->coeffs + r, c); for (i = 0; i < r - 1; i++) { for (j = 0; j < r; j++) { if (i + 1 == j) fmpz_set(M->rows[i] + j, Q); else fmpz_zero(M->rows[i] + j); } } for (j = 0; j < r; j++) { fmpz_poly_evaluate_fmpz(M->rows[r - 1] + j, op->coeffs + j, c); fmpz_neg(M->rows[r - 1] + j, M->rows[r - 1] + j); } fmpz_clear(c); }
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 arb_log_arf_huge(arb_t z, const arf_t x, slong prec) { arf_t t; arb_t c; fmpz_t exp; slong wp; arf_init(t); arb_init(c); fmpz_init(exp); fmpz_neg(exp, ARF_EXPREF(x)); arf_mul_2exp_fmpz(t, x, exp); wp = prec + 4 - fmpz_bits(exp); wp = FLINT_MAX(wp, 4); arb_log_arf(z, t, wp); arb_const_log2(c, prec + 4); arb_submul_fmpz(z, c, exp, prec); arf_clear(t); arb_clear(c); fmpz_clear(exp); }
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 */ } }
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; }
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)); } }
static void entry(fmpz_t rop_u, long *rop_v, const long *u, const long *v, const fmpz *a, const fmpz *dinv, const fmpz **mu, long M, const long **C, const long *lenC, long n, long d, long p, long N, long N2) { const long ku = diagfrob_k(u, n, d); const long kv = diagfrob_k(v, n, d); fmpz_t f, g, P; fmpz_init(f); fmpz_init(g); fmpz_init_set_ui(P, p); /* Compute $g := (u'-1)! \alpha_{u+1,v+1}$ to precision $N2$. */ fmpz_fac_ui(f, ku - 1); alpha(g, u, v, a, dinv, mu, M, C, lenC, n, d, p, N2); fmpz_mul(g, f, g); /* Compute $f := (-1)^{u'+v'} (v'-1)!$ exactly. */ fmpz_fac_ui(f, kv - 1); if ((ku + kv) % 2 != 0) { fmpz_neg(f, f); } /* Set rop to the product of $f$ and $g^{-1} mod $p^N$. */ *rop_v = fmpz_remove(f, f, P) + n - fmpz_remove(g, g, P); if (*rop_v >= N) { fmpz_zero(rop_u); *rop_v = 0; } else { _padic_inv(g, g, P, N - *rop_v); fmpz_mul(rop_u, f, g); fmpz_pow_ui(f, P, N - *rop_v); fmpz_mod(rop_u, rop_u, f); } fmpz_clear(f); fmpz_clear(g); fmpz_clear(P); }
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); }
void fmpz_randtest(fmpz_t f, flint_rand_t state, mp_bitcnt_t bits) { ulong m; fmpz_randtest_unsigned(f, state, bits); m = n_randlimb(state); if (m & UWORD(1)) fmpz_neg(f, f); }
/* 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_div(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) { fmpz_t t, u; fmpz_init(t); fmpz_init(u); fmpz_set(t, op2den); fmpz_set(u, op2num); _fmpq_mul(rnum, rden, op1num, op1den, t, u); fmpz_clear(t); fmpz_clear(u); if (fmpz_sgn(rden) < 0) { fmpz_neg(rnum, rnum); fmpz_neg(rden, rden); } }
void _fmpz_mat_det_bareiss(fmpz_t det, fmpz_mat_t tmp) { long *perm, n = fmpz_mat_nrows(tmp); perm = _perm_init(n); fmpz_mat_fflu(tmp, det, perm, tmp, 1); if (_perm_parity(perm, n) == 1) fmpz_neg(det, det); _perm_clear(perm); }
void acb_quadratic_roots_fmpz(acb_t r1, acb_t r2, const fmpz_t a, const fmpz_t b, const fmpz_t c, slong prec) { fmpz_t d; fmpz_init(d); /* d = b^2 - 4ac */ fmpz_mul(d, a, c); fmpz_mul_2exp(d, d, 2); fmpz_submul(d, b, b); fmpz_neg(d, d); /* +/- sqrt(d) */ acb_zero(r1); if (fmpz_sgn(d) >= 0) { arb_sqrt_fmpz(acb_realref(r1), d, prec + fmpz_bits(d) + 4); } else { fmpz_neg(d, d); arb_sqrt_fmpz(acb_imagref(r1), d, prec + fmpz_bits(d) + 4); } acb_neg(r2, r1); /* -b */ acb_sub_fmpz(r1, r1, b, prec + 4); acb_sub_fmpz(r2, r2, b, prec + 4); /* divide by 2a */ fmpz_mul_2exp(d, a, 1); acb_div_fmpz(r1, r1, d, prec); acb_div_fmpz(r2, r2, d, prec); fmpz_clear(d); return; }
explicit FlintZZ(const ZZ& a) { long n = NumBits(a); fmpz_init(value); for (long i = 0; i < n; i++) if (bit(a, i)) fmpz_setbit(value, i); if (a < 0) fmpz_neg(value, value); }
void acb_lambertw_cleared_cut_fix_small(acb_t res, const acb_t z, const acb_t ez1, const fmpz_t k, int flags, slong prec) { acb_t zz, zmid, zmide1; arf_t eps; acb_init(zz); acb_init(zmid); acb_init(zmide1); arf_init(eps); arf_mul_2exp_si(eps, arb_midref(acb_realref(z)), -prec); acb_set(zz, z); if (arf_sgn(arb_midref(acb_realref(zz))) < 0 && (!fmpz_is_zero(k) || arf_sgn(arb_midref(acb_realref(ez1))) < 0) && arf_cmpabs(arb_midref(acb_imagref(zz)), eps) < 0) { /* now the value must be in [0,2eps] */ arf_get_mag(arb_radref(acb_imagref(zz)), eps); arf_set_mag(arb_midref(acb_imagref(zz)), arb_radref(acb_imagref(zz))); if (arf_sgn(arb_midref(acb_imagref(z))) >= 0) { acb_lambertw_cleared_cut(res, zz, k, flags, prec); } else { fmpz_t kk; fmpz_init(kk); fmpz_neg(kk, k); acb_lambertw_cleared_cut(res, zz, kk, flags, prec); acb_conj(res, res); fmpz_clear(kk); } } else { acb_lambertw_cleared_cut(res, zz, k, flags, prec); } acb_clear(zz); acb_clear(zmid); acb_clear(zmide1); arf_clear(eps); }
void _fmpz_poly_sub(fmpz * res, const fmpz * poly1, slong len1, const fmpz * poly2, slong len2) { slong i, min = FLINT_MIN(len1, len2); for (i = 0; i < min; i++) /* subtract up to the length of the shorter poly */ fmpz_sub(res + i, poly1 + i, poly2 + i); if (poly1 != res) /* copy any remaining coefficients from poly1 */ for (i = min; i < len1; i++) fmpz_set(res + i, poly1 + i); /* careful, it is *always* necessary to negate coeffs from poly2, even if this is already res */ for (i = min; i < len2; i++) fmpz_neg(res + i, poly2 + i); }
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 _fmpq_poly_scalar_div_si(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, long len, long c) { if (c == 1) { if (rpoly != poly) { _fmpz_vec_set(rpoly, poly, len); fmpz_set(rden, den); } } else if (c == -1) { _fmpz_vec_neg(rpoly, poly, len); fmpz_set(rden, den); } else { fmpz_t d, f; fmpz_init(d); fmpz_init(f); fmpz_set_si(f, c); _fmpz_vec_content(d, poly, len); fmpz_gcd(d, d, f); if (c > 0) { _fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d); fmpz_mul_si(rden, den, c / fmpz_get_si(d)); } else { ulong q = (- (ulong) c) / fmpz_get_ui(d); fmpz_neg(d, d); _fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d); fmpz_mul_ui(rden, den, q); } fmpz_clear(d); fmpz_clear(f); } }
void mag_root(mag_t y, const mag_t x, ulong n) { if (n == 0) { mag_inf(y); } else if (n == 1 || mag_is_special(x)) { mag_set(y, x); } else if (n == 2) { mag_sqrt(y, x); } else if (n == 4) { mag_sqrt(y, x); mag_sqrt(y, y); } else { fmpz_t e, f; fmpz_init_set_ui(e, MAG_BITS); fmpz_init(f); /* We evaluate exp(log(1+2^(kn)x)/n) 2^-k where k is chosen so that 2^(kn) x ~= 2^30. TODO: this rewriting is probably unnecessary with the new exp/log functions. */ fmpz_sub(e, e, MAG_EXPREF(x)); fmpz_cdiv_q_ui(e, e, n); fmpz_mul_ui(f, e, n); mag_mul_2exp_fmpz(y, x, f); mag_log1p(y, y); mag_div_ui(y, y, n); mag_exp(y, y); fmpz_neg(e, e); mag_mul_2exp_fmpz(y, y, e); fmpz_clear(e); fmpz_clear(f); } }
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_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 */ } } }