int fmpcb_poly_contains_fmpq_poly(const fmpcb_poly_t poly1, const fmpq_poly_t poly2) { long i; fmpq_t t; if (poly2->length > poly1->length) return 0; fmpq_init(t); for (i = 0; i < poly2->length; i++) { fmpq_poly_get_coeff_fmpq(t, poly2, i); if (!fmpcb_contains_fmpq(poly1->coeffs + i, t)) { fmpq_clear(t); return 0; } } fmpq_clear(t); for (i = poly2->length; i < poly1->length; i++) if (!fmpcb_contains_zero(poly1->coeffs + i)) return 0; return 1; }
int main(void) { int i, result; flint_rand_t state; printf("get_str... "); fflush(stdout); flint_randinit(state); for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t x; fmpq_t y; char *s, *t; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_TERSE); padic_init(x, ctx); fmpq_init(y); padic_randtest(x, state, ctx); _padic_get_fmpq(y, x, ctx); s = _padic_get_str(NULL, x, ctx); t = fmpq_get_str(NULL, 10, y); result = strcmp(s, t) == 0; if (!result) { printf("FAIL:\n\n"); printf("x = "), _padic_print(x, ctx), printf("\n"); printf("y = "), fmpq_clear(y), printf("\n"); abort(); } free(s); free(t); _padic_clear(x); fmpq_clear(y); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("content...."); fflush(stdout); flint_randinit(state); /* Check that content(a f) = abs(a) content(f) */ for (i = 0; i < 10000; i++) { fmpq_poly_t f, g; fmpq_t a, b, c; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_init(a); fmpq_init(b); fmpq_init(c); fmpq_poly_randtest_not_zero(f, state, n_randint(state, 100) + 1, 100); fmpq_randtest_not_zero(a, state, 100); fmpq_poly_scalar_mul_fmpq(g, f, a); fmpq_poly_content(b, g); fmpq_poly_content(c, f); fmpq_mul(c, a, c); fmpq_abs(c, c); result = (fmpq_equal(b, c)); if (!result) { printf("FAIL:\n"); fmpq_poly_print(f), printf("\n\n"); fmpq_poly_print(g), printf("\n\n"); fmpq_print(a), printf("\n\n"); fmpq_print(b), printf("\n\n"); fmpq_print(c), printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_clear(a); fmpq_clear(b); fmpq_clear(c); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("cfrac_bound...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq_t x, r; fmpz * c; slong n, bound; fmpq_init(x); fmpq_init(r); /* Test worst case (quotient of Fibonacci numbers) */ if (n_randint(state, 50) == 1) { slong v = 1 + n_randint(state, 1000); fmpz_fib_ui(fmpq_numref(x), v + 1); fmpz_fib_ui(fmpq_denref(x), v); } else { fmpq_randtest(x, state, 1 + n_randint(state, 1000)); } bound = fmpq_cfrac_bound(x); c = _fmpz_vec_init(bound + 10); n = fmpq_get_cfrac(c, r, x, bound); if (n > bound) { flint_printf("FAIL: length=%wd > bound=%wd\n", n, bound); abort(); } _fmpz_vec_clear(c, bound + 10); fmpq_clear(x); fmpq_clear(r); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("set_si...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq_t x, y; fmpz_t p, q; slong P, Q; fmpq_init(x); fmpq_init(y); fmpz_init(p); fmpz_init(q); P = z_randtest(state); Q = n_randtest_not_zero(state); fmpz_set_si(p, P); fmpz_set_ui(q, Q); fmpq_set_fmpz_frac(x, p, q); fmpq_set_si(y, P, Q); if (!fmpq_is_canonical(y) || !fmpq_equal(x, y)) { flint_printf("FAIL"); flint_printf("p: "); fmpz_print(p); flint_printf("\n"); flint_printf("q: "); fmpz_print(q); flint_printf("\n"); flint_printf("x: "); fmpq_print(x); flint_printf("\n"); flint_printf("y: "); fmpq_print(y); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(p); fmpz_clear(q); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { printf("seq_set_fmpq_pow...."); fflush(stdout); { long i; fmpq_t t, u; fmpz_holonomic_t op; fmpq_t c, initial; fmpz_holonomic_init(op); fmpq_init(t); fmpq_init(u); fmpq_init(c); fmpq_init(initial); fmpq_set_si(c, -7, 3); fmpz_holonomic_seq_set_fmpq_pow(op, c); fmpq_set_si(initial, -2, 1); for (i = 0; i < 20; i++) { fmpz_holonomic_get_nth_fmpq(t, op, initial, 0, i); fmpz_pow_ui(fmpq_numref(u), fmpq_numref(c), i); fmpz_pow_ui(fmpq_denref(u), fmpq_denref(c), i); fmpz_mul_si(fmpq_numref(u), fmpq_numref(u), -2); if (!fmpq_equal(t, u)) { printf("FAIL\n"); printf("i = %ld, t = ", i); fmpq_print(t); printf(" u = "); fmpq_print(u); printf("\n"); abort(); } } fmpq_clear(c); fmpq_clear(t); fmpq_clear(u); fmpq_clear(initial); fmpz_holonomic_clear(op); } flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i; flint_rand_t state; flint_randinit(state); printf("set_cfrac...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq_t x, y, r; fmpz * c; long n, bound; fmpq_init(x); fmpq_init(y); fmpq_init(r); fmpq_randtest(x, state, 1 + n_randint(state, 1000)); bound = fmpq_cfrac_bound(x); c = _fmpz_vec_init(bound); n = fmpq_get_cfrac(c, r, x, bound); fmpq_set_cfrac(y, c, n); if (!fmpq_equal(x, y)) { printf("FAIL: x != y\n"); printf("x = "); fmpq_print(x); printf("\n"); printf("y = "); fmpq_print(y); printf("\n"); printf("c = "); _fmpz_vec_print(c, n); printf("\n\n"); abort(); } _fmpz_vec_clear(c, bound); fmpq_clear(x); fmpq_clear(y); fmpq_clear(r); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
static void _fmpq_poly_oz_sqrt_approx_scale(fmpq_poly_t y, fmpq_poly_t z, const long n, const mpfr_prec_t prec) { /* We scale by about |det(y) · det(z)|^(-1/(2n)) to make it converge faster */ mpfr_t gamma; mpfr_init2(gamma, prec); mpfr_t tmp; mpfr_init2(tmp, prec); fmpq_t gamma_q; fmpq_init(gamma_q); /* det(y) */ fmpq_poly_oz_ideal_norm(gamma_q, y, n, 1); fmpq_get_mpfr(gamma, gamma_q, MPFR_RNDN); /* det(y) · det(z) */ fmpq_poly_oz_ideal_norm(gamma_q, z, n, 1); fmpq_get_mpfr(tmp, gamma_q, MPFR_RNDN); mpfr_mul(gamma, gamma, tmp, MPFR_RNDN); /* (det(y) · det(z))^(-1/(2n)) */ mpfr_root(gamma, gamma, 2*n, MPFR_RNDN); mpfr_ui_div(gamma, 1, gamma, MPFR_RNDN); mpfr_abs(gamma, gamma, MPFR_RNDN); fmpq_set_mpfr(gamma_q, gamma, MPFR_RNDN); fmpq_poly_scalar_mul_fmpq(y, y, gamma_q); fmpq_poly_scalar_mul_fmpq(z, z, gamma_q); fmpq_clear(gamma_q); mpfr_clear(gamma); mpfr_clear(tmp); }
renf_elem_class::~renf_elem_class() noexcept { if (is_fmpq()) fmpq_clear(b); else renf_elem_clear(a, nf->renf_t()); }
RCP<const Number> bernoulli(unsigned long n) { #ifdef HAVE_SYMENGINE_ARB fmpq_t res; fmpq_init(res); bernoulli_fmpq_ui(res, n); mpq_t a; mpq_init(a); fmpq_get_mpq(a, res); rational_class b(a); fmpq_clear(res); mpq_clear(a); return Rational::from_mpq(std::move(b)); #else // TODO: implement a faster algorithm std::vector<rational_class> v(n + 1); for (unsigned m = 0; m <= n; ++m) { v[m] = rational_class(1, m + 1); for (unsigned j = m; j >= 1; --j) { v[j - 1] = j * (v[j - 1] - v[j]); } } return Rational::from_mpq(v[0]); #endif }
renf_elem_class & renf_elem_class::operator=(renf_elem_class && value) noexcept { if (value.nf == nullptr) { if (nf != nullptr) { renf_elem_clear(a, nf->renf_t()); fmpq_init(b); } nf = value.nf; fmpq_swap(b, value.b); } else { if (nf == nullptr) { fmpq_clear(b); renf_elem_init(a, value.nf->renf_t()); } nf = value.nf; renf_elem_swap(a, value.a); } return *this; }
renf_elem_class & renf_elem_class::operator=(const renf_elem_class & value) noexcept { if (value.nf == nullptr) { if (nf != nullptr) { renf_elem_clear(a, nf->renf_t()); nf = nullptr; fmpq_init(b); } } else { if (nf == nullptr) { fmpq_clear(b); renf_elem_init(a, value.nf->renf_t()); nf = value.nf; } else if (value.nf != nf) { renf_elem_clear(a, nf->renf_t()); renf_elem_init(a, value.nf->renf_t()); nf = value.nf; } } if (value.nf == nullptr) fmpq_set(b, value.b); else renf_elem_set(a, value.a, nf->renf_t()); return *this; }
int main() { slong iter; flint_rand_t state; flint_printf("sinh...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_sinh(t, t, MPFR_RNDN); arb_sinh(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_sinh(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void padic_get_mpq(mpq_t rop, const padic_t op, const padic_ctx_t ctx) { fmpq_t t; fmpq_init(t); padic_get_fmpq(t, op, ctx); fmpq_get_mpq(rop, t); fmpq_clear(t); }
void sample(void * arg, ulong count) { info_t * info = (info_t *) arg; slong length = info->length, i, j; int monic = info->monic; int scale; scale = 1000; if (length >= 50) scale = 100; if (length >= 500) scale = 40; flint_rand_t state; flint_randinit(state); fmpq_poly_t pol; nf_t nf; nf_elem_t a; fmpq_t norm; fmpq_poly_init(pol); fmpq_init(norm); for (i = 0; i < count; i++) { random_fmpq_poly(pol, state, length); if (monic) { fmpz_one(fmpq_poly_denref(pol)); fmpq_poly_set_coeff_ui(pol, length - 1, 1); } nf_init(nf, pol); nf_elem_init(a, nf); random_nf_elem(a, state, nf); if (monic) fmpz_one(fmpq_poly_denref(NF_ELEM(a))); prof_start(); for (j = 0; j < scale; j++) { nf_elem_trace(norm, a, nf); } prof_stop(); } fmpq_clear(norm); nf_elem_clear(a, nf); nf_clear(nf); fmpq_poly_clear(pol); flint_randclear(state); }
void padic_set_mpq(padic_t rop, const mpq_t op, const padic_ctx_t ctx) { fmpq_t t; fmpq_init(t); fmpq_set_mpq(t, op); padic_set_fmpq(rop, t, ctx); fmpq_clear(t); }
static void _acb_unit_root(acb_t res, ulong order, slong prec) { fmpq_t t; fmpq_init(t); fmpq_set_si(t, 2, order); arb_sin_cos_pi_fmpq(acb_imagref(res), acb_realref(res), t, prec); fmpq_clear(t); }
int fmpq_mat_is_invertible(const fmpq_mat_t A) { int r; fmpq_t t; fmpq_init(t); fmpq_mat_det(t, A); r = !fmpq_is_zero(t); fmpq_clear(t); return r; }
int main() { slong iter; flint_rand_t state; flint_printf("set_fmpq...."); fflush(stdout); flint_randinit(state); /* test exact roundtrip R -> Q -> R */ for (iter = 0; iter < 100000; iter++) { slong bits, res; fmpr_t x, z; fmpq_t y; bits = 2 + n_randint(state, 200); fmpr_init(x); fmpr_init(z); fmpq_init(y); fmpr_randtest(x, state, bits, 10); fmpr_randtest(z, state, bits, 10); fmpr_get_fmpq(y, x); res = fmpr_set_fmpq(z, y, bits, FMPR_RND_DOWN); if (!fmpr_equal(x, z) || !fmpr_check_ulp(z, res, bits)) { flint_printf("FAIL\n\n"); flint_printf("bits: %wd\n", bits); flint_printf("x = "); fmpr_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); fmpr_print(z); flint_printf("\n\n"); abort(); } fmpr_clear(x); fmpr_clear(z); fmpq_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("series_fmpq_hypgeom...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 250; iter++) { fmprb_ptr u, v; fmpq_t a; ulong p, q; long i, len, prec1, prec2; len = 1 + n_randint(state, 10); prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; u = _fmprb_vec_init(len); v = _fmprb_vec_init(len); fmpq_init(a); q = 1 + n_randint(state, 20); p = q - n_randint(state, q); fmpq_set_si(a, p, q); gamma_series_fmpq_hypgeom(u, a, len, prec1); gamma_series_fmpq_hypgeom(v, a, len, prec2); for (i = 0; i < len; i++) { if (!fmprb_overlaps(u + i, v + i)) { printf("FAIL: overlap\n\n"); printf("p = %lu, q = %lu, len = %ld, i = %ld\n\n", p, q, len, i); printf("u = "); fmprb_printd(u + i, prec1 / 3.33); printf("\n\n"); printf("v = "); fmprb_printd(v + i, prec2 / 3.33); printf("\n\n"); abort(); } } fmpq_clear(a); _fmprb_vec_clear(u, len); _fmprb_vec_clear(v, len); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
void bernoulli_cleanup(void) { long i; for (i = 0; i < bernoulli_cache_num; i++) fmpq_clear(bernoulli_cache + i); flint_free(bernoulli_cache); bernoulli_cache = NULL; bernoulli_cache_num = 0; }
void fmpq_poly_evaluate_mpz(mpq_t res, const fmpq_poly_t poly, const mpz_t a) { fmpq_t r; fmpz_t b; fmpq_init(r); fmpz_init(b); fmpz_set_mpz(b, a); fmpq_poly_evaluate_fmpz(r, poly, b); fmpq_get_mpq(res, r); fmpq_clear(r); fmpz_clear(b); }
int main() { slong i, bound; double a, b; fmpq_t q; fmpr_t t; flint_printf("bound_2exp_si...."); fflush(stdout); fmpq_init(q); fmpr_init(t); for (i = 0; i < 1000; i++) { arith_bernoulli_number(q, i); bound = bernoulli_bound_2exp_si(i); fmpr_set_round_fmpz(t, fmpq_numref(q), 32, FMPR_RND_UP); fmpr_div_fmpz(t, t, fmpq_denref(q), 32, FMPR_RND_UP); if (fmpr_cmpabs_2exp_si(t, bound) > 0) { flint_printf("FAIL: %wd\n", i); fmpr_print(t); flint_printf("\n\n"); flint_printf("%wd\n", bound); flint_printf("\n\n"); abort(); } } fmpq_clear(q); fmpr_clear(t); for (i = 100; i < 4000000; i += 1) { i += (i & 1); a = bernoulli_bound_2exp_si(i); b = log2bern_approx(i); if (a < b || a > 1.01 * b) { flint_printf("FAIL: %wd\n", i); flint_printf("%wd: %f %f %f\n", i, a, b, (float) a / b); abort(); } } flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("sin_pi_fmpq...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t s1, s2; fmpq_t x; slong prec; prec = 2 + n_randint(state, 5000); arb_init(s1); arb_init(s2); fmpq_init(x); fmpq_randtest(x, state, 1 + n_randint(state, 200)); arb_sin_pi_fmpq(s1, x, prec); arb_const_pi(s2, prec); arb_mul_fmpz(s2, s2, fmpq_numref(x), prec); arb_div_fmpz(s2, s2, fmpq_denref(x), prec); arb_sin(s2, s2, prec); if (!arb_overlaps(s1, s2)) { flint_printf("FAIL: overlap\n\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("s1 = "); arb_printd(s1, 15); flint_printf("\n\n"); flint_printf("s2 = "); arb_printd(s2, 15); flint_printf("\n\n"); abort(); } arb_clear(s1); arb_clear(s2); fmpq_clear(x); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("cos_pi_fmpq...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { fmprb_t c1, c2; fmpq_t x; long prec; prec = 2 + n_randint(state, 5000); fmprb_init(c1); fmprb_init(c2); fmpq_init(x); fmpq_randtest(x, state, 1 + n_randint(state, 200)); fmprb_cos_pi_fmpq(c1, x, prec); fmprb_const_pi(c2, prec); fmprb_mul_fmpz(c2, c2, fmpq_numref(x), prec); fmprb_div_fmpz(c2, c2, fmpq_denref(x), prec); fmprb_cos(c2, c2, prec); if (!fmprb_overlaps(c1, c2)) { printf("FAIL: overlap\n\n"); printf("x = "); fmpq_print(x); printf("\n\n"); printf("c1 = "); fmprb_printd(c1, 15); printf("\n\n"); printf("c2 = "); fmprb_printd(c2, 15); printf("\n\n"); abort(); } fmprb_clear(c1); fmprb_clear(c2); fmpq_clear(x); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("set_fmpq...."); fflush(stdout); flint_randinit(state); /* test exact roundtrip R -> Q -> R */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { slong bits, res; arf_t x, z; fmpq_t y; bits = 2 + n_randint(state, 200); arf_init(x); arf_init(z); fmpq_init(y); arf_randtest(x, state, bits, 10); arf_randtest(z, state, bits, 10); arf_get_fmpq(y, x); res = arf_set_fmpq(z, y, bits, ARF_RND_DOWN); if (!arf_equal(x, z) || res != 0) { flint_printf("FAIL\n\n"); flint_printf("bits: %wd\n", bits); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); arf_print(z); flint_printf("\n\n"); abort(); } arf_clear(x); arf_clear(z); fmpq_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_dirichlet_pairing(acb_t res, const dirichlet_group_t G, ulong m, ulong n, slong prec) { ulong expo; expo = dirichlet_pairing(G, m, n); if (expo == DIRICHLET_CHI_NULL) acb_zero(res); else { fmpq_t t; fmpq_init(t); fmpq_set_si(t, 2 * expo, G->expo); arb_sin_cos_pi_fmpq(acb_imagref(res), acb_realref(res), t, prec); fmpq_clear(t); } }
void test_field1(flint_rand_t state) { /* tests in QQ[sqrt(5)] */ int iter; fmpq_t k; fmpq_poly_t p; arb_t emb; renf_t nf; renf_elem_t a; fmpq_poly_init(p); fmpq_poly_set_coeff_si(p, 2, 1); fmpq_poly_set_coeff_si(p, 1, -1); fmpq_poly_set_coeff_si(p, 0, -1); arb_init(emb); arb_set_d(emb, 1.61803398874989); arb_add_error_2exp_si(emb, -20); renf_init(nf, p, emb, 20 + n_randint(state, 20)); arb_clear(emb); renf_elem_init(a, nf); fmpq_init(k); /* (1+sqrt(5))/2 vs Fibonacci */ fmpq_poly_zero(p); fmpq_poly_set_coeff_si(p, 1, -1); for (iter = 1; iter < 50; iter++) { fprintf(stderr, "start iter = %d\n", iter); fflush(stderr); fmpz_fib_ui(fmpq_numref(k), iter+1); fmpz_fib_ui(fmpq_denref(k), iter); fmpq_poly_set_coeff_fmpq(p, 0, k); renf_elem_set_fmpq_poly(a, p, nf); check_ceil(a, nf, 1 - iter % 2, "sqrt(5)"); fprintf(stderr, "end\n"); fflush(stderr); } renf_elem_clear(a, nf); renf_clear(nf); fmpq_clear(k); fmpq_poly_clear(p); }
RCP<const Number> bernoulli(ulong n) { #ifdef HAVE_CSYMPY_ARB fmpq_t res; fmpq_init(res); bernoulli_fmpq_ui(res, n); mpq_t a; mpq_init(a); fmpq_get_mpq(a, res); mpq_class b (a); fmpq_clear(res); mpq_clear(a); return Rational::from_mpq(b); #else throw std::runtime_error("Currently supported only if ARB is installed"); #endif }
renf_elem_class::operator mpq_class() const noexcept { mpq_class z; if (nf == nullptr) fmpq_get_mpq(z.__get_mp(), b); else if (is_rational()) { assert(is_rational() && "renf_elem_class not a rational"); ::fmpq_t q; fmpq_init(q); nf_elem_get_fmpq(q, a->elem, parent().renf_t()->nf); fmpq_get_mpq(z.__get_mp(), q); fmpq_clear(q); } return z; }