static void _newton_to_monomial(arb_ptr ys, arb_srcptr xs, long n, long prec) { arb_t t, u; long i, j; arb_init(t); arb_init(u); for (i = n - 2; i >= 0; i--) { arb_set(t, ys + i); arb_set(ys + i, ys + i + 1); for (j = i + 1; j < n - 1; j++) { arb_mul(u, ys + j, xs + i, prec); arb_sub(ys + j, ys + j + 1, u, prec); } arb_mul(u, ys + n - 1, xs + i, prec); arb_sub(ys + n - 1, t, u, prec); } _arb_poly_reverse(ys, ys, n, n); arb_clear(t); arb_clear(u); }
void _arb_poly_div_root(arb_ptr Q, arb_t R, arb_srcptr A, slong len, const arb_t c, slong prec) { arb_t r, t; slong i; if (len < 2) { arb_zero(R); return; } arb_init(r); arb_init(t); arb_set(t, A + len - 2); arb_set(Q + len - 2, A + len - 1); arb_set(r, Q + len - 2); /* TODO: avoid the extra assignments (but still support aliasing) */ for (i = len - 2; i > 0; i--) { arb_mul(r, r, c, prec); arb_add(r, r, t, prec); arb_set(t, A + i - 1); arb_set(Q + i - 1, r); } arb_mul(r, r, c, prec); arb_add(R, r, t, prec); }
static void _interpolate_newton(arb_ptr ys, arb_srcptr xs, long n, long prec) { arb_t p, q, t; long i, j; arb_init(p); arb_init(q); arb_init(t); for (i = 1; i < n; i++) { arb_set(t, ys + i - 1); for (j = i; j < n; j++) { arb_sub(p, ys + j, t, prec); arb_sub(q, xs + j, xs + j - i, prec); arb_set(t, ys + j); arb_div(ys + j, p, q, prec); } } arb_clear(p); arb_clear(q); arb_clear(t); }
void _arb_poly_evaluate_rectangular(arb_t y, arb_srcptr poly, long len, const arb_t x, long prec) { long i, j, m, r; arb_ptr xs; arb_t s, t, c; if (len < 3) { if (len == 0) { arb_zero(y); } else if (len == 1) { arb_set_round(y, poly + 0, prec); } else if (len == 2) { arb_mul(y, x, poly + 1, prec); arb_add(y, y, poly + 0, prec); } return; } m = n_sqrt(len) + 1; r = (len + m - 1) / m; xs = _arb_vec_init(m + 1); arb_init(s); arb_init(t); arb_init(c); _arb_vec_set_powers(xs, x, m + 1, prec); arb_set(y, poly + (r - 1) * m); for (j = 1; (r - 1) * m + j < len; j++) arb_addmul(y, xs + j, poly + (r - 1) * m + j, prec); for (i = r - 2; i >= 0; i--) { arb_set(s, poly + i * m); for (j = 1; j < m; j++) arb_addmul(s, xs + j, poly + i * m + j, prec); arb_mul(y, y, xs + m, prec); arb_add(y, y, s, prec); } _arb_vec_clear(xs, m + 1); arb_clear(s); arb_clear(t); arb_clear(c); }
void arb_div_2expm1_ui(arb_t y, const arb_t x, ulong n, long prec) { if (n < FLINT_BITS) { arb_div_ui(y, x, (1UL << n) - 1, prec); } else if (n < 1024 + prec / 32 || n > LONG_MAX / 4) { arb_t t; fmpz_t e; arb_init(t); fmpz_init_set_ui(e, n); arb_one(t); arb_mul_2exp_fmpz(t, t, e); arb_sub_ui(t, t, 1, prec); arb_div(y, x, t, prec); arb_clear(t); fmpz_clear(e); } else { arb_t s, t; long i, b; arb_init(s); arb_init(t); /* x / (2^n - 1) = sum_{k>=1} x * 2^(-k*n)*/ arb_mul_2exp_si(s, x, -n); arb_set(t, s); b = 1; for (i = 2; i <= prec / n + 1; i++) { arb_mul_2exp_si(t, t, -n); arb_add(s, s, t, prec); b = i; } /* error bound: sum_{k>b} x * 2^(-k*n) <= x * 2^(-b*n - (n-1)) */ arb_mul_2exp_si(t, x, -b*n - (n-1)); arb_abs(t, t); arb_add_error(s, t); arb_set(y, s); arb_clear(s); arb_clear(t); } }
void arb_agm(arb_t z, const arb_t x, const arb_t y, long prec) { arb_t t, u, v, w; if (arb_contains_negative(x) || arb_contains_negative(y)) { arb_indeterminate(z); return; } if (arb_is_zero(x) || arb_is_zero(y)) { arb_zero(z); return; } arb_init(t); arb_init(u); arb_init(v); arb_init(w); arb_set(t, x); arb_set(u, y); while (!arb_overlaps(t, u) && !arb_contains_nonpositive(t) && !arb_contains_nonpositive(u)) { arb_add(v, t, u, prec); arb_mul_2exp_si(v, v, -1); arb_mul(w, t, u, prec); arb_sqrt(w, w, prec); arb_swap(v, t); arb_swap(w, u); } if (!arb_is_finite(t) || !arb_is_finite(u)) { arb_indeterminate(z); } else { arb_union(z, t, u, prec); } arb_clear(t); arb_clear(u); arb_clear(v); arb_clear(w); }
void arb_hypgeom_coulomb_jet(arb_ptr F, arb_ptr G, const arb_t l, const arb_t eta, const arb_t z, slong len, slong prec) { acb_ptr tmp, tmpF, tmpG; slong k; if (len <= 0) return; if (len == 1) { arb_hypgeom_coulomb(F, G, l, eta, z, prec); return; } tmp = _acb_vec_init(3); tmpF = _acb_vec_init(len); tmpG = _acb_vec_init(len); acb_set_arb(tmp, l); acb_set_arb(tmp + 1, eta); acb_set_arb(tmp + 2, z); acb_hypgeom_coulomb_jet(F ? tmpF : NULL, G ? tmpG : NULL, NULL, NULL, tmp, tmp + 1, tmp + 2, len, prec); if (F != NULL) { if (acb_is_real(tmpF)) for (k = 0; k < len; k++) arb_set(F + k, acb_realref(tmpF + k)); else _arb_vec_indeterminate(F, len); } if (G != NULL) { if (acb_is_real(tmpG)) for (k = 0; k < len; k++) arb_set(G + k, acb_realref(tmpG + k)); else _arb_vec_indeterminate(G, len); } _acb_vec_clear(tmpF, len); _acb_vec_clear(tmpG, len); _acb_vec_clear(tmp, 3); }
void _arb_poly_reverse(arb_ptr res, arb_srcptr poly, slong len, slong n) { if (res == poly) { slong i; for (i = 0; i < n / 2; i++) { arb_struct t = res[i]; res[i] = res[n - 1 - i]; res[n - 1 - i] = t; } for (i = 0; i < n - len; i++) arb_zero(res + i); } else { slong i; for (i = 0; i < n - len; i++) arb_zero(res + i); for (i = 0; i < len; i++) arb_set(res + (n - len) + i, poly + (len - 1) - i); } }
void _arb_poly_sinh_cosh_series(arb_ptr s, arb_ptr c, const arb_srcptr h, slong hlen, slong n, slong prec) { hlen = FLINT_MIN(hlen, n); if (hlen == 1) { arb_sinh_cosh(s, c, h, prec); _arb_vec_zero(s + 1, n - 1); _arb_vec_zero(c + 1, n - 1); } else if (n == 2) { arb_t t; arb_init(t); arb_set(t, h + 1); arb_sinh_cosh(s, c, h, prec); arb_mul(s + 1, c, t, prec); arb_mul(c + 1, s, t, prec); arb_clear(t); } else if (hlen < 60 || n < 120) _arb_poly_sinh_cosh_series_basecase(s, c, h, hlen, n, prec); else _arb_poly_sinh_cosh_series_exponential(s, c, h, hlen, n, prec); }
void arb_hypgeom_hermite_h(arb_t res, const arb_t nu, const arb_t z, slong prec) { acb_t t, u; acb_init(t); acb_init(u); arb_set(acb_realref(t), nu); arb_set(acb_realref(u), z); acb_hypgeom_hermite_h(t, t, u, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); acb_clear(t); acb_clear(u); }
void arb_hypgeom_gamma_upper(arb_t res, const arb_t s, const arb_t z, int regularized, slong prec) { acb_t t, u; acb_init(t); acb_init(u); arb_set(acb_realref(t), s); arb_set(acb_realref(u), z); acb_hypgeom_gamma_upper(t, t, u, regularized, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); acb_clear(t); acb_clear(u); }
int arb_mat_lu(long * P, arb_mat_t LU, const arb_mat_t A, long prec) { arb_t d, e; arb_ptr * a; long i, j, m, n, r, row, col; int result; m = arb_mat_nrows(A); n = arb_mat_ncols(A); result = 1; if (m == 0 || n == 0) return result; arb_mat_set(LU, A); a = LU->rows; row = col = 0; for (i = 0; i < m; i++) P[i] = i; arb_init(d); arb_init(e); while (row < m && col < n) { r = arb_mat_find_pivot_partial(LU, row, m, col); if (r == -1) { result = 0; break; } else if (r != row) arb_mat_swap_rows(LU, P, row, r); arb_set(d, a[row] + col); for (j = row + 1; j < m; j++) { arb_div(e, a[j] + col, d, prec); arb_neg(e, e); _arb_vec_scalar_addmul(a[j] + col, a[row] + col, n - col, e, prec); arb_zero(a[j] + col); arb_neg(a[j] + row, e); } row++; col++; } arb_clear(d); arb_clear(e); return result; }
static __inline__ void arb_nonnegative_part(arb_t z, const arb_t x, long prec) { if (arb_contains_negative(x)) { arf_t t; arf_init(t); arf_set_mag(t, arb_radref(x)); arf_add(arb_midref(z), arb_midref(x), t, MAG_BITS, ARF_RND_CEIL); if (arf_sgn(arb_midref(z)) <= 0) { mag_zero(arb_radref(z)); } else { arf_mul_2exp_si(arb_midref(z), arb_midref(z), -1); arf_get_mag(arb_radref(z), arb_midref(z)); /* XXX: needed since arf_get_mag is inexact */ arf_set_mag(arb_midref(z), arb_radref(z)); } arf_clear(t); } else { arb_set(z, x); } }
int main() { slong iter; flint_rand_t state; flint_printf("csch...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_t x, a, b; slong prec1, prec2; prec1 = 2 + n_randint(state, 200); prec2 = prec1 + 30; arb_init(x); arb_init(a); arb_init(b); arb_randtest_special(x, state, 1 + n_randint(state, 300), 100); arb_randtest_special(a, state, 1 + n_randint(state, 300), 100); arb_randtest_special(b, state, 1 + n_randint(state, 300), 100); if (n_randint(state, 2)) { arb_csch(a, x, prec1); } else { arb_set(a, x); arb_csch(a, a, prec1); } arb_sinh(b, x, prec2); arb_inv(b, b, prec2); /* check consistency */ if (!arb_overlaps(a, b)) { flint_printf("FAIL: overlap\n\n"); flint_printf("x = "); arb_printn(x, 20, 0); flint_printf("\n\n"); flint_printf("a = "); arb_printn(a, 20, 0); flint_printf("\n\n"); flint_printf("b = "); arb_printn(b, 20, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(x); arb_clear(a); arb_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void nd_accum_accumulate(nd_accum_t a, int *coords, arb_struct *value, slong prec) { int axis_idx; int offset, coord, stride; nd_axis_struct *axis; arb_struct *p; arb_t x; arb_init(x); arb_set(x, value); offset = 0; for (axis_idx = 0; axis_idx < a->ndim; axis_idx++) { axis = a->axes + axis_idx; coord = coords[axis_idx]; stride = a->strides[axis_idx]; /* flint_printf("debug:\n"); flint_printf("ndim=%wd axis=%d coord=%d\n", a->ndim, axis_idx, coord); flint_printf("strides:\n"); { int j; for (j = 0; j < a->ndim; j++) { flint_printf("%d : %d\n", j, a->strides[j]); } } */ if (axis->agg_weights) { arb_mul(x, x, axis->agg_weights + coord, prec); /* todo: delay this division */ arb_div(x, x, axis->agg_weight_divisor, prec); } else { offset += coord * stride; } } if (offset < 0) { fprintf(stderr, "internal error: negative offset\n"); abort(); } if (offset >= a->size) { fprintf(stderr, "internal error: offset=%d >= size=%d\n", offset, a->size); abort(); } p = a->data + offset; arb_add(p, p, x, prec); arb_clear(x); }
void arb_hypgeom_pfq(arb_t res, arb_srcptr a, slong p, arb_srcptr b, slong q, const arb_t z, int regularized, slong prec) { acb_ptr t; slong i; t = _acb_vec_init(p + q + 1); for (i = 0; i < p; i++) arb_set(acb_realref(t + i), a + i); for (i = 0; i < q; i++) arb_set(acb_realref(t + p + i), b + i); arb_set(acb_realref(t + p + q), z); acb_hypgeom_pfq(t, t, p, t + p, q, t + p + q, regularized, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); _acb_vec_clear(t, p + q + 1); }
void arb_hypgeom_legendre_q(arb_t res, const arb_t n, const arb_t m, const arb_t z, int type, slong prec) { acb_t t, u, v; acb_init(t); acb_init(u); acb_init(v); arb_set(acb_realref(t), n); arb_set(acb_realref(u), m); arb_set(acb_realref(v), z); acb_hypgeom_legendre_q(t, t, u, v, type, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); acb_clear(t); acb_clear(u); acb_clear(v); }
void _acb_hypgeom_const_li2_eval(arb_t s, long prec) { acb_t t; acb_init(t); acb_set_ui(t, 2); _acb_hypgeom_li(t, t, prec); arb_set(s, acb_realref(t)); acb_clear(t); }
void arb_hypgeom_beta_lower(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec) { acb_t t, u, v; acb_init(t); acb_init(u); acb_init(v); arb_set(acb_realref(t), a); arb_set(acb_realref(u), b); arb_set(acb_realref(v), z); acb_hypgeom_beta_lower(t, t, u, v, regularized, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); acb_clear(t); acb_clear(u); acb_clear(v); }
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_hypgeom_bessel_jy(arb_t res1, arb_t res2, const arb_t nu, const arb_t z, slong prec) { acb_t t, u; acb_init(t); acb_init(u); arb_set(acb_realref(t), nu); arb_set(acb_realref(u), z); acb_hypgeom_bessel_jy(t, u, t, u, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res1, acb_realref(t)); else arb_indeterminate(res1); if (acb_is_finite(u) && acb_is_real(u)) arb_swap(res2, acb_realref(u)); else arb_indeterminate(res2); acb_clear(t); acb_clear(u); }
void arb_hypgeom_jacobi_p(arb_t res, const arb_t n, const arb_t a, const arb_t b, const arb_t z, slong prec) { acb_t t, u, v, w; acb_init(t); acb_init(u); acb_init(v); acb_init(w); arb_set(acb_realref(t), n); arb_set(acb_realref(u), a); arb_set(acb_realref(v), b); arb_set(acb_realref(w), z); acb_hypgeom_jacobi_p(t, t, u, v, w, prec); if (acb_is_finite(t) && acb_is_real(t)) arb_swap(res, acb_realref(t)); else arb_indeterminate(res); acb_clear(t); acb_clear(u); acb_clear(v); acb_clear(w); }
static void bsplit(arb_poly_t pol, const arb_t sqrtD, const slong * qbf, slong a, slong b, slong prec) { if (b - a == 0) { arb_poly_one(pol); } else if (b - a == 1) { acb_t z; acb_init(z); /* j((-b+sqrt(-D))/(2a)) */ arb_set_si(acb_realref(z), -FLINT_ABS(qbf[3 * a + 1])); arb_set(acb_imagref(z), sqrtD); acb_div_si(z, z, 2 * qbf[3 * a], prec); acb_modular_j(z, z, prec); if (qbf[3 * a + 1] < 0) { /* (x^2 - 2re(j) x + |j|^2) */ arb_poly_fit_length(pol, 3); arb_mul(pol->coeffs, acb_realref(z), acb_realref(z), prec); arb_addmul(pol->coeffs, acb_imagref(z), acb_imagref(z), prec); arb_mul_2exp_si(pol->coeffs + 1, acb_realref(z), 1); arb_neg(pol->coeffs + 1, pol->coeffs + 1); arb_one(pol->coeffs + 2); _arb_poly_set_length(pol, 3); } else { /* (x-j) */ arb_poly_fit_length(pol, 2); arb_neg(pol->coeffs, acb_realref(z)); arb_one(pol->coeffs + 1); _arb_poly_set_length(pol, 2); } acb_clear(z); } else { arb_poly_t tmp; arb_poly_init(tmp); bsplit(pol, sqrtD, qbf, a, a + (b - a) / 2, prec); bsplit(tmp, sqrtD, qbf, a + (b - a) / 2, b, prec); arb_poly_mul(pol, pol, tmp, prec); arb_poly_clear(tmp); } }
int sin_x(arb_ptr out, const arb_t inp, void * params, long order, long prec) { int xlen = FLINT_MIN(2, order); arb_set(out, inp); if (xlen > 1) arb_one(out + 1); _arb_poly_sin_series(out, out, xlen, order, prec); eval_count++; return 0; }
void arb_poly_set_coeff_arb(arb_poly_t poly, long n, const arb_t x) { arb_poly_fit_length(poly, n + 1); if (n + 1 > poly->length) { _arb_vec_zero(poly->coeffs + poly->length, n - poly->length); poly->length = n + 1; } arb_set(poly->coeffs + n, x); _arb_poly_normalise(poly); }
int arb_calc_newton_step(arb_t xnew, arb_calc_func_t func, void * param, const arb_t x, const arb_t conv_region, const arf_t conv_factor, slong prec) { mag_t err, v; arb_t t; arb_struct u[2]; int result; mag_init(err); mag_init(v); arb_init(t); arb_init(u + 0); arb_init(u + 1); mag_mul(err, arb_radref(x), arb_radref(x)); arf_get_mag(v, conv_factor); mag_mul(err, err, v); arf_set(arb_midref(t), arb_midref(x)); mag_zero(arb_radref(t)); func(u, t, param, 2, prec); arb_div(u, u, u + 1, prec); arb_sub(u, t, u, prec); mag_add(arb_radref(u), arb_radref(u), err); if (arb_contains(conv_region, u) && (mag_cmp(arb_radref(u), arb_radref(x)) < 0)) { arb_swap(xnew, u); result = ARB_CALC_SUCCESS; } else { arb_set(xnew, x); result = ARB_CALC_NO_CONVERGENCE; } arb_clear(t); arb_clear(u); arb_clear(u + 1); mag_clear(err); mag_clear(v); return result; }
int arb_calc_refine_root_newton(arb_t r, arb_calc_func_t func, void * param, const arb_t start, const arb_t conv_region, const arf_t conv_factor, slong eval_extra_prec, slong prec) { slong precs[FLINT_BITS]; slong i, iters, wp, padding, start_prec; int result; start_prec = arb_rel_accuracy_bits(start); if (arb_calc_verbose) flint_printf("newton initial accuracy: %wd\n", start_prec); padding = arf_abs_bound_lt_2exp_si(conv_factor); padding = FLINT_MIN(padding, prec) + 5; padding = FLINT_MAX(0, padding); precs[0] = prec + padding; iters = 1; while ((iters < FLINT_BITS) && (precs[iters-1] + padding > 2*start_prec)) { precs[iters] = (precs[iters-1] / 2) + padding; iters++; if (iters == FLINT_BITS) { return ARB_CALC_IMPRECISE_INPUT; } } arb_set(r, start); for (i = iters - 1; i >= 0; i--) { wp = precs[i] + eval_extra_prec; if (arb_calc_verbose) flint_printf("newton step: wp = %wd + %wd = %wd\n", precs[i], eval_extra_prec, wp); if ((result = arb_calc_newton_step(r, func, param, r, conv_region, conv_factor, wp)) != ARB_CALC_SUCCESS) { return result; } } return ARB_CALC_SUCCESS; }
int f_thsh_shift(arb_t max, const arb_t t, params_t * p, slong prec) { acb_t z; acb_init(z); arb_set(acb_realref(z), t); arb_set_d(acb_imagref(z), .7); acb_sinh(z, z, prec); acb_tanh(z, z, prec); acb_abs(max, z, prec); acb_clear(z); return 1; }
int _arb_poly_newton_step(arb_t xnew, arb_srcptr poly, long len, const arb_t x, const arb_t convergence_interval, const arf_t convergence_factor, long prec) { arf_t err; arb_t t, u, v; int result; arf_init(err); arb_init(t); arb_init(u); arb_init(v); arf_set_mag(err, arb_radref(x)); arf_mul(err, err, err, MAG_BITS, ARF_RND_UP); arf_mul(err, err, convergence_factor, MAG_BITS, ARF_RND_UP); arf_set(arb_midref(t), arb_midref(x)); mag_zero(arb_radref(t)); _arb_poly_evaluate2(u, v, poly, len, t, prec); arb_div(u, u, v, prec); arb_sub(u, t, u, prec); arb_add_error_arf(u, err); if (arb_contains(convergence_interval, u) && (mag_cmp(arb_radref(u), arb_radref(x)) < 0)) { arb_swap(xnew, u); result = 1; } else { arb_set(xnew, x); result = 0; } arb_clear(t); arb_clear(u); arb_clear(v); arf_clear(err); return result; }
static void bound_I(arb_ptr I, const arb_t A, const arb_t B, const arb_t C, slong len, slong wp) { slong k; arb_t D, Dk, L, T, Bm1; arb_init(D); arb_init(Dk); arb_init(Bm1); arb_init(T); arb_init(L); arb_sub_ui(Bm1, B, 1, wp); arb_one(L); /* T = 1 / (A^Bm1 * Bm1) */ arb_inv(T, A, wp); arb_pow(T, T, Bm1, wp); arb_div(T, T, Bm1, wp); if (len > 1) { arb_log(D, A, wp); arb_add(D, D, C, wp); arb_mul(D, D, Bm1, wp); arb_set(Dk, D); } for (k = 0; k < len; k++) { if (k > 0) { arb_mul_ui(L, L, k, wp); arb_add(L, L, Dk, wp); arb_mul(Dk, Dk, D, wp); } arb_mul(I + k, L, T, wp); arb_div(T, T, Bm1, wp); } arb_clear(D); arb_clear(Dk); arb_clear(Bm1); arb_clear(T); arb_clear(L); }