int main() { slong iter; flint_rand_t state; flint_printf("set_interval_mpfr...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t x; arf_t a, b; mpfr_t aa, bb; arb_init(x); arf_init(a); arf_init(b); mpfr_init2(aa, 200); mpfr_init2(bb, 200); arf_randtest_special(a, state, 200, 10); arf_randtest_special(b, state, 200, 10); if (arf_cmp(a, b) > 0) arf_swap(a, b); arf_get_mpfr(aa, a, MPFR_RNDD); arf_get_mpfr(bb, b, MPFR_RNDU); arb_set_interval_mpfr(x, aa, bb, 2 + n_randint(state, 200)); if (!arb_contains_arf(x, a) || !arb_contains_arf(x, b)) { flint_printf("FAIL:\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_abort(); } arb_clear(x); arf_clear(a); arf_clear(b); mpfr_clear(aa); mpfr_clear(bb); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
static __inline__ void zeta_bsplit_init(zeta_bsplit_t S) { arb_init(S->A); arb_init(S->B); arb_init(S->C); arb_init(S->D); arb_init(S->Q1); arb_init(S->Q2); arb_init(S->Q3); }
static void bound_rfac(arb_ptr F, const acb_t s, ulong n, slong len, slong wp) { if (len == 1) { acb_rising_ui_get_mag(arb_radref(F), s, n); arf_set_mag(arb_midref(F), arb_radref(F)); mag_zero(arb_radref(F + 0)); } else { arb_struct sx[2]; arb_init(sx + 0); arb_init(sx + 1); acb_abs(sx + 0, s, wp); arb_one(sx + 1); _arb_vec_zero(F, len); _arb_poly_rising_ui_series(F, sx, 2, n, len, wp); arb_clear(sx + 0); arb_clear(sx + 1); } }
int main() { slong iter; flint_rand_t state; flint_printf("const_e...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 250 * arb_test_multiplier(); iter++) { arb_t r; mpfr_t s; slong accuracy, prec; prec = 2 + n_randint(state, 1 << n_randint(state, 16)); arb_init(r); mpfr_init2(s, prec + 1000); arb_const_e(r, prec); mpfr_set_ui(s, 1, MPFR_RNDN); mpfr_exp(s, s, MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("prec = %wd\n", prec); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { flint_printf("FAIL: poor accuracy\n\n"); flint_printf("prec = %wd\n", prec); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void _arb_poly_evaluate_horner(arb_t y, arb_srcptr f, slong len, const arb_t x, slong prec) { if (len == 0) { arb_zero(y); } else if (len == 1 || arb_is_zero(x)) { arb_set_round(y, f, prec); } else if (len == 2) { arb_mul(y, x, f + 1, prec); arb_add(y, y, f + 0, prec); } else { slong i = len - 1; arb_t t, u; arb_init(t); arb_init(u); arb_set(u, f + i); for (i = len - 2; i >= 0; i--) { arb_mul(t, u, x, prec); arb_add(u, f + i, t, prec); } arb_swap(y, u); arb_clear(t); arb_clear(u); } }
renf_elem_class::operator double() const noexcept { if (nf == nullptr) { arb_t s; arb_init(s); arb_set_fmpq(s, b, 128); double ans = arf_get_d(arb_midref(s), ARF_RND_NEAR); arb_clear(s); return ans; } else return renf_elem_get_d(a, nf->renf_t(), ARF_RND_NEAR); }
int main() { int iter; FLINT_TEST_INIT(state); test_field1(state); test_field2(state); for (iter = 0; iter < 100; iter++) { renf_t nf; renf_elem_t a; fmpz_t f; arb_t e; fmpz_init(f); arb_init(e); renf_randtest(nf, state, 2 + n_randint(state, 20), /* length */ 8 + n_randint(state, 2408), /* prec */ 10 + n_randint(state, 10) /* bits */ ); renf_elem_init(a, nf); renf_elem_randtest(a, state, 30 + n_randint(state, 10), nf); renf_elem_ceil(f, a, nf); arb_sub_fmpz(e, a->emb, f, 1024); if (arb_is_positive(e)) { printf("FAIL:\n"); abort(); } arb_add_ui(e, e, 1, 1024); if (arb_is_negative(e)) { printf("FAIL:\n"); abort(); } renf_elem_clear(a, nf); renf_clear(nf); fmpz_clear(f); arb_clear(e); } FLINT_TEST_CLEANUP(state); return 0; }
/* TODO: BSGS can reduce to nv mul */ void acb_dirichlet_arb_quadratic_powers(arb_ptr v, slong nv, const arb_t x, slong prec) { slong i; arb_t dx, x2; arb_init(dx); arb_init(x2); arb_set(dx, x); arb_mul(x2, x, x, prec); for (i = 0; i < nv; i++) { if (i == 0) arb_one(v + i); else if (i == 1) arb_set_round(v + i, x, prec); else { arb_mul(dx, dx, x2, prec); arb_mul(v + i, v + i - 1, dx, prec); } } arb_clear(dx); arb_clear(x2); }
std::string renf_elem_class::to_string(int flags) const noexcept { std::string s; assert(!((flags & EANTIC_STR_D) && (flags & EANTIC_STR_ARB))); // call to renf_elem_get_str_pretty if (nf == nullptr) { if (flags & EANTIC_STR_ALG) { char * u = fmpq_get_str(nullptr, 10, b); s += u; flint_free(u); if (flags & (EANTIC_STR_D | EANTIC_STR_ARB)) s += " ~ "; } if (flags & EANTIC_STR_D) { char * u = (char *) flint_malloc(20 * sizeof(char)); sprintf(u, "%lf", fmpq_get_d(b)); s += u; flint_free(u); } if (flags & EANTIC_STR_ARB) { char * u; arb_t x; arb_init(x); arb_set_fmpq(x, b, 128); u = arb_get_str(x, 64, 0); s += u; arb_clear(x); flint_free(u); } } else { char * u = renf_elem_get_str_pretty(renf_elem_t(), parent().gen_name().c_str(), parent().renf_t(), 10, flags); s += u; flint_free(u); } if (flags != EANTIC_STR_ALG && flags != EANTIC_STR_D && flags != EANTIC_STR_ARB) return "(" + s + ")"; else return s; }
void _arb_poly_tan_series(arb_ptr g, arb_srcptr h, slong hlen, slong len, slong prec) { hlen = FLINT_MIN(hlen, len); if (hlen == 1) { arb_tan(g, h, prec); _arb_vec_zero(g + 1, len - 1); } else if (len == 2) { arb_t t; arb_init(t); arb_tan(g, h, prec); arb_mul(t, g, g, prec); arb_add_ui(t, t, 1, prec); arb_mul(g + 1, t, h + 1, prec); /* safe since hlen >= 2 */ arb_clear(t); } else { arb_ptr t, u; t = _arb_vec_init(2 * len); u = t + len; NEWTON_INIT(TAN_NEWTON_CUTOFF, len) NEWTON_BASECASE(n) _arb_poly_sin_cos_series_basecase(t, u, h, hlen, n, prec, 0); _arb_poly_div_series(g, t, n, u, n, n, prec); NEWTON_END_BASECASE NEWTON_LOOP(m, n) _arb_poly_mullow(u, g, m, g, m, n, prec); arb_add_ui(u, u, 1, prec); _arb_poly_atan_series(t, g, m, n, prec); _arb_poly_sub(t + m, h + m, FLINT_MAX(0, hlen - m), t + m, n - m, prec); _arb_poly_mullow(g + m, u, n, t + m, n - m, n - m, prec); NEWTON_END_LOOP NEWTON_END _arb_vec_clear(t, 2 * len); } }
void nd_axis_init(nd_axis_t axis, const char *name, int total_count, column_reduction_t r, int component_axis_count, struct nd_component_axis *component_axes, slong prec) { int i, idx; /* set compound axis hack data */ axis->component_axis_count = component_axis_count; axis->component_axes = component_axes; /* set the name */ axis->name = malloc(strlen(name) + 1); strcpy(axis->name, name); /* set the counts */ axis->n = total_count; axis->k = r->selection_len; /* allocate some bookkeeping vectors */ axis->selection = calloc(axis->k, sizeof(int)); axis->is_selected = calloc(axis->n, sizeof(int)); axis->request_update = calloc(axis->n, sizeof(int)); /* initialize the bookkeeping vectors */ for (i = 0; i < axis->k; i++) { idx = r->selection[i]; axis->selection[i] = idx; axis->is_selected[idx] = 1; axis->request_update[idx] = 1; } /* initialize the arbitrary precision weight arrays */ if (r->agg_mode == AGG_NONE) { axis->agg_weights = NULL; } else { axis->agg_weights = _arb_vec_init(axis->n); arb_init(axis->agg_weight_divisor); } /* initialize weight values */ nd_axis_update_precision(axis, r, prec); }
/* 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); } }
/* compose by poly2 = a*x^n + c, no aliasing; n >= 1 */ void _arb_poly_compose_axnc(arb_ptr res, arb_srcptr poly1, slong len1, const arb_t c, const arb_t a, slong n, slong prec) { slong i; _arb_vec_set_round(res, poly1, len1, prec); /* shift by c (c = 0 case will be fast) */ _arb_poly_taylor_shift(res, c, len1, prec); /* multiply by powers of a */ if (!arb_is_one(a)) { if (arb_equal_si(a, -1)) { for (i = 1; i < len1; i += 2) arb_neg(res + i, res + i); } else if (len1 == 2) { arb_mul(res + 1, res + 1, a, prec); } else { arb_t t; arb_init(t); arb_set(t, a); for (i = 1; i < len1; i++) { arb_mul(res + i, res + i, t, prec); if (i + 1 < len1) arb_mul(t, t, a, prec); } arb_clear(t); } } /* stretch */ for (i = len1 - 1; i >= 1 && n > 1; i--) { arb_swap(res + i * n, res + i); _arb_vec_zero(res + (i - 1) * n + 1, n - 1); } }
static void _acb_hypgeom_li_offset(acb_t res, const acb_t z, long prec) { if (acb_is_int(z) && arf_cmp_2exp_si(arb_midref(acb_realref(z)), 1) == 0) { acb_zero(res); } else { arb_t t; arb_init(t); _acb_hypgeom_const_li2(t, prec); _acb_hypgeom_li(res, z, prec); arb_sub(acb_realref(res), acb_realref(res), t, prec); arb_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); }
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); } }
slong renf_set_embeddings_fmpz_poly(renf * nf, fmpz_poly_t pol, slong lim, slong prec) { slong i, n, n_exact, n_interval; fmpq_poly_t p2; arb_t a; fmpz * c; slong * k; n = fmpz_poly_num_real_roots_upper_bound(pol); c = _fmpz_vec_init(n); k = (slong *) flint_malloc(n * sizeof(slong)); fmpz_poly_isolate_real_roots(NULL, &n_exact, c, k, &n_interval, pol); if (n_exact) { fprintf(stderr, "ERROR (fmpz_poly_real_embeddings): rational roots\n"); abort(); } arb_init(a); fmpq_poly_init(p2); fmpz_one(fmpq_poly_denref(p2)); fmpq_poly_fit_length(p2, pol->length); _fmpz_vec_set(p2->coeffs, pol->coeffs, pol->length); p2->length = pol->length; for (i = 0; i < FLINT_MIN(lim, n_interval); i++) { arb_set_fmpz(a, c + i); arb_mul_2exp_si(a, a, 1); arb_add_si(a, a, 1, prec); mag_one(arb_radref(a)); arb_mul_2exp_si(a, a, k[i] - 1); renf_init(nf + i, p2, a, prec); } arb_clear(a); fmpq_poly_clear(p2); _fmpz_vec_clear(c, n); flint_free(k); return n_interval; }
void arb_fac2_ui(arb_t res, ulong n, long prec) { if (n % 2 == 0) { arb_fac_ui(res, n / 2, prec); arb_mul_2exp_si(res, res, n / 2); } else { arb_t t; arb_init(t); arb_fac2_ui(t, n - 1, prec + 5); arb_fac_ui(res, n, prec + 5); arb_div(res, res, t, prec); arb_clear(t); } }
void _arb_pow_exp(arb_t z, const arb_t x, int negx, const arb_t y, long prec) { arb_t t; arb_init(t); if (negx) { arb_neg(t, x); arb_log(t, t, prec); } else arb_log(t, x, prec); arb_mul(t, t, y, prec); arb_exp(z, t, prec); arb_clear(t); }
void check_init(fmpq_poly_t p, double demb, double rad1, double rad2, slong iter, flint_rand_t state) { renf_t nf; arb_t emb; slong prec, i; arb_init(emb); for (i = 0; i < iter; i++) { prec = 8 + n_randint(state, 2048); randomized_embedding(emb, demb, rad1, rad2); renf_init(nf, p, emb, prec); check_renf(nf); renf_clear(nf); } arb_clear(emb); }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_ui_asymp...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { arb_t r; ulong n; mpfr_t s; slong prec; prec = 2 + n_randint(state, 1 << n_randint(state, 10)); arb_init(r); mpfr_init2(s, prec + 100); n = 2 + n_randint(state, 1 << n_randint(state, 10)); arb_zeta_ui_asymp(r, n, prec); mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n, ULONG_MAX), MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n"); abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("get_coeff_ptr...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 1000; i++) { arb_poly_t A; arb_t a; long n = n_randint(state, 100); arb_poly_init(A); arb_poly_randtest(A, state, n_randint(state, 100), 100, 10); arb_init(a); arb_poly_get_coeff_arb(a, A, n); result = n < arb_poly_length(A) ? arb_equal(a, arb_poly_get_coeff_ptr(A, n)) : arb_poly_get_coeff_ptr(A, n) == NULL; if (!result) { printf("FAIL:\n"); printf("A = "), arb_poly_printd(A, 10), printf("\n\n"); printf("a = "), arb_print(a), printf("\n\n"); printf("n = %ld\n\n", n); abort(); } arb_poly_clear(A); arb_clear(a); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return 0; }
int f_aj(arb_t m, const arb_t t, params_t * p, slong prec) { slong k; acb_t z, zu; arb_t abs; arb_init(abs); acb_init(z); acb_init(zu); arb_const_pi(abs, prec); arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */ arb_set(acb_realref(z), t); arb_set(acb_imagref(z), abs); acb_sinh(z, z, prec); arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */ acb_mul_arb(z, z, abs, prec); acb_tanh(z, z, prec); arb_one(m); for (k = 0; k < p->len; k++) { acb_sub(zu, z, p->z + k, prec); if (acb_contains_zero(zu)) { arb_clear(abs); acb_clear(zu); acb_clear(z); return 0; } acb_abs(abs, zu, prec); arb_mul(m, m, abs, prec); } arb_inv(m, m, prec); arb_clear(abs); acb_clear(zu); acb_clear(z); return 1; }
void arb_poly_fit_length(arb_poly_t poly, slong len) { slong i; if (len > poly->alloc) { if (len < 2 * poly->alloc) len = 2 * poly->alloc; poly->coeffs = flint_realloc(poly->coeffs, len * sizeof(arb_struct)); for (i = poly->alloc; i < len; i++) arb_init(poly->coeffs + i); poly->alloc = len; } }
/* rate matrix and edge rates have already been updated */ static void _update_transition_matrices(cross_site_ws_t w, slong prec) { slong i, j; arb_t s; arb_init(s); for (i = 0; i < w->rate_category_count; i++) { for (j = 0; j < w->edge_count; j++) { arb_mat_struct *tmat; tmat = cross_site_ws_transition_matrix(w, i, j); arb_mul(s, w->rate_mix_rates + i, w->edge_rates + j, prec); arb_mat_scalar_mul_arb(tmat, w->rate_matrix, s, prec); arb_mat_exp(tmat, tmat, prec); } } arb_clear(s); }
/* * Update the frechet matrix for each rate category and edge. * At this point the rate matrix has been normalized * to have zero row sums, but it has not been scaled * by the edge rate coefficients. * The frechet matrices must already have been initialized. */ static void _update_state_pair_frechet_matrices( cross_site_ws_t csw, model_and_data_t m, nd_axis_struct *edge_axis, slong first_state, slong second_state, slong prec) { arb_mat_t P, L, Q; slong cat; arb_t rate; slong state_count = model_and_data_state_count(m); slong edge_count = model_and_data_edge_count(m); slong rate_category_count = model_and_data_rate_category_count(m); arb_init(rate); arb_mat_init(P, state_count, state_count); arb_mat_init(L, state_count, state_count); arb_mat_init(Q, state_count, state_count); arb_set(arb_mat_entry(L, first_state, second_state), arb_mat_entry(csw->rate_matrix, first_state, second_state)); for (cat = 0; cat < rate_category_count; cat++) { slong edge; const arb_struct * cat_rate = csw->rate_mix_rates + cat; for (edge = 0; edge < edge_count; edge++) { slong idx = m->edge_map->order[edge]; const arb_struct * edge_rate = csw->edge_rates + idx; arb_mat_struct *fmat; if (!edge_axis->request_update[edge]) continue; fmat = cross_site_ws_trans_frechet_matrix(csw, cat, idx); arb_mul(rate, edge_rate, cat_rate, prec); arb_mat_scalar_mul_arb(Q, csw->rate_matrix, rate, prec); _arb_mat_exp_frechet(P, fmat, Q, L, prec); } } arb_clear(rate); arb_mat_clear(P); arb_mat_clear(L); arb_mat_clear(Q); }
void arb_twobytwo_diag(arb_t u1, arb_t u2, const arb_t a, const arb_t b, const arb_t d, slong prec) { // Compute the orthogonal matrix that diagonalizes // // A = [a b] // [b d] // // This matrix will have the form // // U = [cos x , -sin x] // [sin x, cos x] // // where the diagonal matrix is U^t A U. // We set u1 = cos x, u2 = -sin x. if(arb_contains_zero(b)) { // this is not quite right (doesn't set error intervals) arb_set_ui(u1, 1); arb_set_ui(u2, 0); return; } arb_t x; arb_init(x); arb_mul(u1, b, b, prec); // u1 = b^2 arb_sub(u2, a, d, prec); // u2 = a - d arb_mul_2exp_si(u2, u2, -1); // u2 = (a - d)/2 arb_mul(u2, u2, u2, prec); // u2 = ( (a - d)/2 )^2 arb_add(u1, u1, u2, prec); // u1 = b^2 + ( (a-d)/2 )^2 arb_sqrt(u1, u1, prec); // u1 = sqrt(above) arb_mul_2exp_si(u1, u1, 1); // u1 = 2 (sqrt (above) ) arb_add(u1, u1, d, prec); // u1 += d arb_sub(u1, u1, a, prec); // u1 -= a arb_mul_2exp_si(u1, u1, -1); // u1 = (d - a)/2 + sqrt(b^2 + ( (a-d)/2 )^2) arb_mul(x, u1, u1, prec); arb_addmul(x, b, b, prec); // x = u1^2 + b^2 arb_sqrt(x, x, prec); // x = sqrt(u1^2 + b^2) arb_div(u2, u1, x, prec); arb_div(u1, b, x, prec); arb_neg(u1, u1); arb_clear(x); }
/* series of c^(d+x) */ static __inline__ void _arb_poly_pow_cpx(arb_ptr res, const arb_t c, const arb_t d, long trunc, long prec) { long i; arb_t logc; arb_init(logc); arb_log(logc, c, prec); arb_mul(res + 0, logc, d, prec); arb_exp(res + 0, res + 0, prec); for (i = 1; i < trunc; i++) { arb_mul(res + i, res + i - 1, logc, prec); arb_div_ui(res + i, res + i, i, prec); } arb_clear(logc); }
/* invalid in (-1,0) */ int _acb_hypgeom_legendre_q_single_valid(const acb_t z) { arb_t t; int ok; if (!arb_contains_zero(acb_imagref(z))) return 1; if (arb_is_positive(acb_imagref(z))) return 1; arb_init(t); arb_one(t); arb_neg(t, t); ok = arb_lt(acb_realref(z), t); arb_clear(t); return ok; }
void _arb_poly_compose_series(arb_ptr res, arb_srcptr poly1, slong len1, arb_srcptr poly2, slong len2, slong n, slong prec) { if (len2 == 1) { arb_set_round(res, poly1, prec); _arb_vec_zero(res + 1, n - 1); } else if (_arb_vec_is_zero(poly2 + 1, len2 - 2)) /* poly2 is a monomial */ { slong i, j; arb_t t; arb_init(t); arb_set(t, poly2 + len2 - 1); arb_set_round(res, poly1, prec); for (i = 1, j = len2 - 1; i < len1 && j < n; i++, j += len2 - 1) { arb_mul(res + j, poly1 + i, t, prec); if (i + 1 < len1 && j + len2 - 1 < n) arb_mul(t, t, poly2 + len2 - 1, prec); } if (len2 != 2) for (i = 1; i < n; i++) if (i % (len2 - 1) != 0) arb_zero(res + i); arb_clear(t); } else if (len1 < 6 || n < 6) { _arb_poly_compose_series_horner(res, poly1, len1, poly2, len2, n, prec); } else { _arb_poly_compose_series_brent_kung(res, poly1, len1, poly2, len2, n, prec); } }