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);
}
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);
}
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);
}
/* TODO: set number of threads in child threads, for future
multithreaded evaluation of single terms */
static void
hrr_sum_threaded(arb_t x, const fmpz_t n, slong N, int use_doubles)
{
arb_t y;
pthread_t threads[2];
worker_arg_t args[2];
arb_init(y);
args[0].x = x;
args[0].n = (fmpz *) n;
args[0].N0 = 1;
args[0].N = 16;
args[0].use_doubles = use_doubles;
args[1].x = y;
args[1].n = (fmpz *) n;
args[1].N0 = 17;
args[1].N = N;
args[1].use_doubles = use_doubles;
pthread_create(&threads[0], NULL, worker, &args[0]);
pthread_create(&threads[1], NULL, worker, &args[1]);
pthread_join(threads[0], NULL);
pthread_join(threads[1], NULL);
arb_add(x, x, y, ARF_PREC_EXACT);
arb_clear(y);
}
void
_arb_poly_product_roots(arb_ptr poly, arb_srcptr xs, slong n, slong prec)
{
if (n == 0)
{
arb_one(poly);
}
else if (n == 1)
{
arb_neg(poly, xs);
arb_one(poly + 1);
}
else if (n == 2)
{
arb_mul(poly, xs + 0, xs + 1, prec);
arb_add(poly + 1, xs + 0, xs + 1, prec);
arb_neg(poly + 1, poly + 1);
arb_one(poly + 2);
}
else
{
const slong m = (n + 1) / 2;
arb_ptr tmp;
tmp = _arb_vec_init(n + 2);
_arb_poly_product_roots(tmp, xs, m, prec);
_arb_poly_product_roots(tmp + m + 1, xs + m, n - m, prec);
_arb_poly_mul_monic(poly, tmp, m + 1, tmp + m + 1, n - m + 1, prec);
_arb_vec_clear(tmp, n + 2);
}
}
void
acb_polygamma(acb_t res, const acb_t s, const acb_t z, long prec)
{
if (acb_is_zero(s))
{
acb_digamma(res, z, prec);
}
else if (acb_is_int(s) && arb_is_positive(acb_realref(s)))
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_add_ui(t, s, 1, prec);
acb_gamma(u, t, prec);
acb_hurwitz_zeta(t, t, z, prec);
if (arf_is_int_2exp_si(arb_midref(acb_realref(s)), 1))
acb_neg(t, t);
acb_mul(res, t, u, prec);
acb_clear(t);
acb_clear(u);
}
else
{
acb_t t, u;
acb_struct v[2];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(v + 1);
/* u = psi(-s) + gamma */
acb_neg(t, s);
acb_digamma(u, t, prec);
arb_const_euler(acb_realref(v), prec);
arb_add(acb_realref(u), acb_realref(u), acb_realref(v), prec);
acb_add_ui(t, s, 1, prec);
_acb_poly_zeta_cpx_series(v, t, z, 0, 2, prec);
acb_addmul(v + 1, v, u, prec);
acb_neg(t, s);
acb_rgamma(u, t, prec);
acb_mul(res, v + 1, u, prec);
acb_clear(v);
acb_clear(v + 1);
acb_clear(t);
acb_clear(u);
}
}
static void
_update_aggregated_state_frechet_matrices(
cross_site_ws_t csw, model_and_data_t m,
nd_axis_struct *edge_axis, nd_axis_struct *trans_axis,
const int *first_idx, const int *second_idx, slong prec)
{
arb_mat_t P, L, Q;
arb_t rate;
slong first_state, second_state;
slong cat, trans_idx;
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);
/* set entries of L to the requested transition weights */
for (trans_idx = 0; trans_idx < trans_axis->n; trans_idx++)
{
first_state = first_idx[trans_idx];
second_state = second_idx[trans_idx];
arb_add(arb_mat_entry(L, first_state, second_state),
arb_mat_entry(L, first_state, second_state),
trans_axis->agg_weights + trans_idx, prec);
}
/* multiply entries of L by the rate matrix entries */
arb_mat_mul_entrywise(L, L, csw->rate_matrix, prec);
/* divide L by the global weight divisor */
arb_mat_scalar_div_arb(L, L, trans_axis->agg_weight_divisor, prec);
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
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_addmul_naive(arb_t z, const arb_t x, const arb_t y, slong prec)
{
arb_t t;
arb_init(t);
arb_mul(t, x, y, ARF_PREC_EXACT);
arb_add(z, z, t, prec);
arb_clear(t);
}
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);
}
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);
}
int main()
{
long p = 1000;
long d = 53;
arb_t a, b, x, t;
arb_init(a);
arb_init(b);
arb_init(x);
arb_init(t);
// a = 1 + 2 ^ -76
arb_set_str(a, "2", p);
arb_set_str(t, "-76", p);
arb_pow(a, a, t, p);
arb_set_str(t, "1", p);
arb_add(a, t, a, p);
printf("a = "); arb_printd(a, d); printf("\n");
// b = 4 ^ 38 + 0.5
arb_set_str(b, "0.5", p);
arb_ui_pow_ui(t, 4, 38, p);
arb_add(b, t, b, p);
printf("b = "); arb_printd(b, d); printf("\n");
// x = a ^ b
arb_pow(x, a, b, p);
printf("x = "); arb_printd(x, d); printf("\n");
arb_const_e(t, p);
printf("e = "); arb_printd(t, d); printf("\n");
arb_sub(t, x, t, p);
printf("x-e = "); arb_printd(t, d); printf("\n");
printf("Computed with arb-%s\n", arb_version);
arb_clear(a);
arb_clear(b);
arb_clear(x);
arb_clear(t);
}
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);
}
}
void
_arb_poly_add(arb_ptr res, arb_srcptr poly1, slong len1,
arb_srcptr poly2, slong len2, slong prec)
{
slong i, min = FLINT_MIN(len1, len2);
for (i = 0; i < min; i++)
arb_add(res + i, poly1 + i, poly2 + i, prec);
for (i = min; i < len1; i++)
arb_set_round(res + i, poly1 + i, prec);
for (i = min; i < len2; i++)
arb_set_round(res + i, poly2 + i, prec);
}
void
custom_rate_mixture_expectation(arb_t rate, const custom_rate_mixture_t x, slong prec)
{
if (x->mode == RATE_MIXTURE_UNDEFINED)
{
flint_fprintf(stderr, "internal error: undefined rate mixture\n");
abort();
}
else if (x->mode == RATE_MIXTURE_NONE)
{
arb_one(rate);
}
else if (x->mode == RATE_MIXTURE_UNIFORM || x->mode == RATE_MIXTURE_CUSTOM)
{
slong i;
arb_t tmp, tmpb;
arb_init(tmp);
arb_init(tmpb);
arb_zero(rate);
if (x->mode == RATE_MIXTURE_UNIFORM)
{
for (i = 0; i < x->n; i++)
{
arb_set_d(tmp, x->rates[i]);
arb_add(rate, rate, tmp, prec);
}
arb_div_si(rate, rate, x->n, prec);
}
else if (x->mode == RATE_MIXTURE_CUSTOM)
{
for (i = 0; i < x->n; i++)
{
arb_set_d(tmp, x->rates[i]);
arb_set_d(tmpb, x->prior[i]);
arb_addmul(rate, tmp, tmpb, prec);
}
}
arb_clear(tmp);
arb_clear(tmpb);
}
else
{
flint_fprintf(stderr, "internal error: "
"unrecognized rate mixture mode\n");
abort();
}
}
static void _stirling_number_2_vec_next(arb_ptr row,
arb_srcptr prev, slong n, slong klen, slong prec)
{
slong k;
if (klen > n) arb_one(row + n);
if (n != 0 && klen != 0) arb_zero(row);
for (k = FLINT_MIN(n, klen) - 1; k >= 1; k--)
{
arb_mul_ui(row + k, prev + k, k, prec);
arb_add(row + k, prev + k - 1, row + k, prec);
}
for (k = n + 1; k < klen; k++)
arb_zero(row + k);
}
int
acb_modular_is_in_fundamental_domain(const acb_t z, const arf_t tol, long prec)
{
arb_t t;
arb_init(t);
/* require re(w) + 1/2 >= 0 */
arb_set_ui(t, 1);
arb_mul_2exp_si(t, t, -1);
arb_add(t, t, acb_realref(z), prec);
arb_add_arf(t, t, tol, prec);
if (!arb_is_nonnegative(t))
{
arb_clear(t);
return 0;
}
/* require re(w) - 1/2 <= 0 */
arb_set_ui(t, 1);
arb_mul_2exp_si(t, t, -1);
arb_sub(t, acb_realref(z), t, prec);
arb_sub_arf(t, t, tol, prec);
if (!arb_is_nonpositive(t))
{
arb_clear(t);
return 0;
}
/* require |w| >= 1 - tol, i.e. |w| - 1 + tol >= 0 */
acb_abs(t, z, prec);
arb_sub_ui(t, t, 1, prec);
arb_add_arf(t, t, tol, prec);
if (!arb_is_nonnegative(t))
{
arb_clear(t);
return 0;
}
arb_clear(t);
return 1;
}
void
arb_acosh(arb_t z, const arb_t x, slong prec)
{
if (arb_is_one(x))
{
arb_zero(z);
}
else
{
arb_t t;
arb_init(t);
arb_mul(t, x, x, prec + 4);
arb_sub_ui(t, t, 1, prec + 4);
arb_sqrt(t, t, prec + 4);
arb_add(t, t, x, prec + 4);
arb_log(z, t, prec);
arb_clear(t);
}
}
void
acb_hypgeom_ci_2f3(acb_t res, const acb_t z, slong prec)
{
acb_t a, t, u;
acb_struct b[3];
acb_init(a);
acb_init(b);
acb_init(b + 1);
acb_init(b + 2);
acb_init(t);
acb_init(u);
acb_one(a);
acb_set_ui(b, 2);
acb_set(b + 1, b);
acb_set_ui(b + 2, 3);
acb_mul_2exp_si(b + 2, b + 2, -1);
acb_mul(t, z, z, prec);
acb_mul_2exp_si(t, t, -2);
acb_neg(t, t);
acb_hypgeom_pfq_direct(u, a, 1, b, 3, t, -1, prec);
acb_mul(u, u, t, prec);
acb_log(t, z, prec);
acb_add(u, u, t, prec);
arb_const_euler(acb_realref(t), prec);
arb_add(acb_realref(u), acb_realref(u), acb_realref(t), prec);
acb_swap(res, u);
acb_clear(a);
acb_clear(b);
acb_clear(b + 1);
acb_clear(b + 2);
acb_clear(t);
acb_clear(u);
}
void
arb_mat_trace(arb_t trace, const arb_mat_t mat, slong prec)
{
slong i;
if (!arb_mat_is_square(mat))
{
flint_printf("arb_mat_trace: a square matrix is required!\n");
abort();
}
if (arb_mat_is_empty(mat))
{
arb_zero(trace);
return;
}
arb_set(trace, arb_mat_entry(mat, 0, 0));
for (i = 1; i < arb_mat_nrows(mat); i++)
{
arb_add(trace, trace, arb_mat_entry(mat, i, i), prec);
}
}
void
_arb_poly_taylor_shift_horner(arb_ptr poly, const arb_t c, slong n, slong prec)
{
slong i, j;
if (arb_is_one(c))
{
for (i = n - 2; i >= 0; i--)
for (j = i; j < n - 1; j++)
arb_add(poly + j, poly + j, poly + j + 1, prec);
}
else if (arb_equal_si(c, -1))
{
for (i = n - 2; i >= 0; i--)
for (j = i; j < n - 1; j++)
arb_sub(poly + j, poly + j, poly + j + 1, prec);
}
else if (!arb_is_zero(c))
{
for (i = n - 2; i >= 0; i--)
for (j = i; j < n - 1; j++)
arb_addmul(poly + j, poly + j + 1, c, prec);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("coth....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x, y, a, b, c, d;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
arb_init(x);
arb_init(y);
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_precise(x, state, 1 + n_randint(state, 1000), 100);
arb_randtest_precise(y, state, 1 + n_randint(state, 1000), 100);
arb_coth(a, x, prec1);
arb_coth(b, x, prec2);
/* check consistency */
if (!arb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
abort();
}
/* check coth(x+y) = (1 + coth(x) coth(y)) / (coth(x) + coth(y)) */
arb_add(b, x, y, prec1);
arb_coth(b, b, prec1);
arb_coth(c, y, prec1);
arb_add(d, a, c, prec1);
arb_mul(c, a, c, prec1);
arb_add_ui(c, c, 1, prec1);
arb_div(d, c, d, prec1);
if (!arb_overlaps(b, d))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("y = "); arb_print(y); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
abort();
}
arb_coth(x, x, prec1);
if (!arb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
abort();
}
arb_clear(x);
arb_clear(y);
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("add....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t a, b, c;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
arb_init(c);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_randtest(c, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
arb_add(c, a, b, 2 + n_randint(state, 200));
fmpq_add(z, x, y);
if (!arb_contains_fmpq(c, z))
{
printf("FAIL: containment\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("x = "); fmpq_print(x); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("y = "); fmpq_print(y); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
printf("z = "); fmpq_print(z); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* aliasing of c and a */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
arb_add(a, a, b, 2 + n_randint(state, 200));
fmpq_add(z, x, y);
if (!arb_contains_fmpq(a, z))
{
printf("FAIL: aliasing (c, a)\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("x = "); fmpq_print(x); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("y = "); fmpq_print(y); printf("\n\n");
printf("z = "); fmpq_print(z); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* aliasing of c and b */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
arb_add(b, a, b, 2 + n_randint(state, 200));
fmpq_add(z, x, y);
if (!arb_contains_fmpq(b, z))
{
printf("FAIL: aliasing (c, b)\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("x = "); fmpq_print(x); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("y = "); fmpq_print(y); printf("\n\n");
printf("z = "); fmpq_print(z); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("log....");
fflush(stdout);
flint_randinit(state);
/* compare with mpfr */
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);
do {
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
} while (arb_contains_nonpositive(a));
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
/* todo: estimate cancellation precisely */
if (mpfr_cmp_d(t, 1 - 1e-10) > 0 && mpfr_cmp_d(t, 1 + 1e-10) < 0)
{
mpfr_set_prec(t, prec + 1000);
fmpq_get_mpfr(t, q, MPFR_RNDN);
}
mpfr_log(t, t, MPFR_RNDN);
arb_log(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");
abort();
}
arb_log(a, a, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* compare with mpfr (higher precision) */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b;
fmpq_t q;
mpfr_t t;
slong prec = 2 + n_randint(state, 6000);
arb_init(a);
arb_init(b);
fmpq_init(q);
mpfr_init2(t, prec + 100);
do {
arb_randtest(a, state, 1 + n_randint(state, 6000), 10);
} while (arb_contains_nonpositive(a));
arb_randtest(b, state, 1 + n_randint(state, 6000), 10);
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
/* todo: estimate cancellation precisely */
if (mpfr_cmp_d(t, 1 - 1e-10) > 0 && mpfr_cmp_d(t, 1 + 1e-10) < 0)
{
mpfr_set_prec(t, prec + 10000);
fmpq_get_mpfr(t, q, MPFR_RNDN);
}
mpfr_log(t, t, MPFR_RNDN);
arb_log(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");
abort();
}
arb_log(a, a, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* test large numbers */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, ab, lab, la, lb, lalb;
slong prec = 2 + n_randint(state, 6000);
arb_init(a);
arb_init(b);
arb_init(ab);
arb_init(lab);
arb_init(la);
arb_init(lb);
arb_init(lalb);
arb_randtest(a, state, 1 + n_randint(state, 400), 400);
arb_randtest(b, state, 1 + n_randint(state, 400), 400);
arb_log(la, a, prec);
arb_log(lb, b, prec);
arb_mul(ab, a, b, prec);
arb_log(lab, ab, prec);
arb_add(lalb, la, lb, prec);
if (!arb_overlaps(lab, lalb))
{
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_printf("la = "); arb_print(la); flint_printf("\n\n");
flint_printf("lb = "); arb_print(lb); flint_printf("\n\n");
flint_printf("ab = "); arb_print(ab); flint_printf("\n\n");
flint_printf("lab = "); arb_print(lab); flint_printf("\n\n");
flint_printf("lalb = "); arb_print(lalb); flint_printf("\n\n");
abort();
}
arb_log(a, a, prec);
if (!arb_overlaps(a, la))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(ab);
arb_clear(lab);
arb_clear(la);
arb_clear(lb);
arb_clear(lalb);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("taylor_shift_convolution....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
slong prec1, prec2;
arb_poly_t f, g;
arb_t c, d, e;
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
arb_poly_init(f);
arb_poly_init(g);
arb_init(c);
arb_init(d);
arb_init(e);
arb_poly_randtest(f, state, 1 + n_randint(state, 40), 1 + n_randint(state, 500), 10);
arb_poly_randtest(g, state, 1 + n_randint(state, 20), 1 + n_randint(state, 500), 10);
if (n_randint(state, 2))
arb_set_si(c, n_randint(state, 5) - 2);
else
arb_randtest(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
if (n_randint(state, 2))
arb_set_si(d, n_randint(state, 5) - 2);
else
arb_randtest(d, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
arb_add(e, c, d, prec1);
/* check f(x+c)(x+d) = f(x+c+d) */
arb_poly_taylor_shift_convolution(g, f, e, prec2);
arb_poly_taylor_shift_convolution(f, f, c, prec1);
arb_poly_taylor_shift_convolution(f, f, d, prec1);
if (!arb_poly_overlaps(f, g))
{
flint_printf("FAIL\n\n");
flint_printf("c = ");
arb_printd(c, 15);
flint_printf("\n\n");
flint_printf("d = ");
arb_printd(d, 15);
flint_printf("\n\n");
flint_printf("f = ");
arb_poly_printd(f, 15);
flint_printf("\n\n");
flint_printf("g = ");
arb_poly_printd(g, 15);
flint_printf("\n\n");
abort();
}
arb_poly_clear(f);
arb_poly_clear(g);
arb_clear(c);
arb_clear(d);
arb_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_calc_cauchy_bound(arb_t bound, acb_calc_func_t func, void * param,
const acb_t x, const arb_t radius, slong maxdepth, slong prec)
{
slong i, n, depth, wp;
arb_t pi, theta, v, s1, c1, s2, c2, st, ct;
acb_t t, u;
arb_t b;
arb_init(pi);
arb_init(theta);
arb_init(v);
arb_init(s1);
arb_init(c1);
arb_init(s2);
arb_init(c2);
arb_init(st);
arb_init(ct);
acb_init(t);
acb_init(u);
arb_init(b);
wp = prec + 20;
arb_const_pi(pi, wp);
arb_zero_pm_inf(b);
for (depth = 0, n = 16; depth < maxdepth; n *= 2, depth++)
{
arb_zero(b);
/* theta = 2 pi / n */
arb_div_ui(theta, pi, n, wp);
arb_mul_2exp_si(theta, theta, 1);
/* sine and cosine of i*theta and (i+1)*theta */
arb_zero(s1);
arb_one(c1);
arb_sin_cos(st, ct, theta, wp);
arb_set(s2, st);
arb_set(c2, ct);
for (i = 0; i < n; i++)
{
/* sine and cosine of 2 pi ([i,i+1]/n) */
/* since we use power of two subdivision points, the
sine and cosine are monotone on each subinterval */
arb_union(acb_realref(t), c1, c2, wp);
arb_union(acb_imagref(t), s1, s2, wp);
acb_mul_arb(t, t, radius, wp);
acb_add(t, t, x, prec);
/* next angle */
arb_mul(v, c2, ct, wp);
arb_mul(c1, s2, st, wp);
arb_sub(c1, v, c1, wp);
arb_mul(v, c2, st, wp);
arb_mul(s1, s2, ct, wp);
arb_add(s1, v, s1, wp);
arb_swap(c1, c2);
arb_swap(s1, s2);
func(u, t, param, 1, prec);
acb_abs(v, u, prec);
arb_add(b, b, v, prec);
}
arb_div_ui(b, b, n, prec);
if (arb_is_positive(b))
break;
}
arb_set(bound, b);
arb_clear(pi);
arb_clear(theta);
arb_clear(v);
acb_clear(t);
acb_clear(u);
arb_clear(b);
arb_clear(s1);
arb_clear(c1);
arb_clear(s2);
arb_clear(c2);
arb_clear(st);
arb_clear(ct);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("legendre_p_ui_root....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100 * arb_test_multiplier(); iter++)
{
ulong n, k;
slong prec;
arb_ptr roots, weights;
arb_poly_t pol;
arb_t s;
fmpq_poly_t pol2;
n = 1 + n_randint(state, 100);
prec = 20 + n_randint(state, 500);
roots = _arb_vec_init(n);
weights = _arb_vec_init(n);
arb_poly_init(pol);
fmpq_poly_init(pol2);
arb_init(s);
for (k = 0; k < n; k++)
{
if (k > n / 2 && n_randint(state, 2))
{
arb_neg(roots + k, roots + n - k - 1);
arb_set(weights + k, weights + n - k - 1);
}
else
{
arb_hypgeom_legendre_p_ui_root(roots + k, weights + k, n, k, prec);
}
}
arb_poly_product_roots(pol, roots, n, prec);
/* fmpq_poly_legendre_p(pol2, n); */
arith_legendre_polynomial(pol2, n);
arb_set_fmpz(s, pol2->coeffs + n);
arb_div_fmpz(s, s, pol2->den, prec);
arb_poly_scalar_mul(pol, pol, s, prec);
if (!arb_poly_contains_fmpq_poly(pol, pol2))
{
flint_printf("FAIL: polynomial containment\n\n");
flint_printf("n = %wu, prec = %wd\n\n", n, prec);
flint_printf("pol = "); arb_poly_printd(pol, 30); flint_printf("\n\n");
flint_printf("pol2 = "); fmpq_poly_print(pol2); flint_printf("\n\n");
flint_abort();
}
arb_zero(s);
for (k = 0; k < n; k++)
{
arb_add(s, s, weights + k, prec);
}
if (!arb_contains_si(s, 2))
{
flint_printf("FAIL: sum of weights\n\n");
flint_printf("n = %wu, prec = %wd\n\n", n, prec);
flint_printf("s = "); arb_printn(s, 30, 0); flint_printf("\n\n");
flint_abort();
}
_arb_vec_clear(roots, n);
_arb_vec_clear(weights, n);
arb_poly_clear(pol);
fmpq_poly_clear(pol2);
arb_clear(s);
}
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
arb_t x1, x2, w1, w2;
ulong n, k;
slong prec1, prec2;
arb_init(x1);
arb_init(x2);
arb_init(w1);
arb_init(w2);
n = 1 + n_randtest(state) % 100000;
if (n_randint(state, 2) || n == 1)
k = n_randtest(state) % n;
else
k = n / 2 - (n_randtest(state) % (n / 2));
prec1 = 2 + n_randtest(state) % 2000;
prec2 = 2 + n_randtest(state) % 2000;
arb_hypgeom_legendre_p_ui_root(x1, w1, n, k, prec1);
if (n_randint(state, 10) == 0)
arb_hypgeom_legendre_p_ui_root(x1, NULL, n, k, prec1);
arb_hypgeom_legendre_p_ui_root(x2, w2, n, k, prec2);
if (!arb_overlaps(x1, x2) || !arb_overlaps(w1, w2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu, k = %wu, prec1 = %wd, prec2 = %wd\n\n", n, k, prec1, prec2);
flint_printf("x1 = "); arb_printn(x1, 100, 0); flint_printf("\n\n");
flint_printf("x2 = "); arb_printn(x2, 100, 0); flint_printf("\n\n");
flint_printf("w1 = "); arb_printn(w1, 100, 0); flint_printf("\n\n");
flint_printf("w2 = "); arb_printn(w2, 100, 0); flint_printf("\n\n");
flint_abort();
}
if (arb_rel_accuracy_bits(x1) < prec1 - 3 || arb_rel_accuracy_bits(w1) < prec1 - 3)
{
flint_printf("FAIL: accuracy\n\n");
flint_printf("n = %wu, k = %wu, prec1 = %wd\n\n", n, k, prec1);
flint_printf("acc(x1) = %wd, acc(w1) = %wd\n\n", arb_rel_accuracy_bits(x1), arb_rel_accuracy_bits(w1));
flint_printf("x1 = "); arb_printn(x1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_printf("w1 = "); arb_printn(w1, prec1, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_abort();
}
if (arb_rel_accuracy_bits(x2) < prec2 - 3 || arb_rel_accuracy_bits(w2) < prec2 - 3)
{
flint_printf("FAIL: accuracy 2\n\n");
flint_printf("n = %wu, k = %wu, prec2 = %wd\n\n", n, k, prec2);
flint_printf("acc(x2) = %wd, acc(w2) = %wd\n\n", arb_rel_accuracy_bits(x2), arb_rel_accuracy_bits(w2));
flint_printf("x2 = "); arb_printn(x2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_printf("w2 = "); arb_printn(w2, prec2, ARB_STR_CONDENSE * 30); flint_printf("\n\n");
flint_abort();
}
arb_clear(x1);
arb_clear(x2);
arb_clear(w1);
arb_clear(w2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_ci_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, w, v, one;
acb_init(t);
acb_init(u);
acb_init(w);
acb_init(v);
acb_init(one);
acb_one(one);
acb_mul_onei(w, z);
/* u = U(1,1,iz) */
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
/* v = e^(-iz) */
acb_neg(v, w);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (acb_is_real(z))
{
arb_div(acb_realref(t), acb_imagref(t), acb_realref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-iz) */
acb_neg(w, w);
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, w, prec);
acb_mul_2exp_si(t, t, -1);
}
if (arb_is_zero(acb_realref(z)))
{
if (arb_is_positive(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
}
else if (arb_is_negative(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
arb_neg(acb_imagref(t), acb_imagref(t));
}
else
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* 0 if positive or positive imaginary
pi if upper left quadrant (including negative real axis)
-pi if lower left quadrant (including negative imaginary axis) */
if (arb_is_positive(acb_realref(z)))
{
/* do nothing */
}
else if (arb_is_negative(acb_realref(z)) && arb_is_nonnegative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_nonpositive(acb_realref(z)) && arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi] */
acb_const_pi(u, prec);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(w);
acb_clear(v);
acb_clear(one);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("power_sum_vec....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b, s, t;
arb_ptr res;
slong aa, bb, k, n, len;
slong prec;
len = n_randint(state, 30);
prec = 2 + n_randint(state, 500);
aa = n_randint(state, 50) - 50;
bb = aa + n_randint(state, 50);
arb_init(a);
arb_init(b);
arb_init(s);
arb_init(t);
res = _arb_vec_init(len);
arb_set_si(a, aa);
arb_set_si(b, bb);
arb_power_sum_vec(res, a, b, len, prec);
for (n = 0; n < len; n++)
{
arb_zero(s);
for (k = aa; k < bb; k++)
{
arb_set_si(t, k);
arb_pow_ui(t, t, n, prec);
arb_add(s, s, t, prec);
}
if (!arb_overlaps(res + n, s))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = %wd, b = %wd, n = %wd\n\n", aa, bb, n);
flint_printf("res = "); arb_printd(res + n, 30); flint_printf("\n\n");
flint_printf("s = "); arb_printd(s, 30); flint_printf("\n\n");
abort();
}
}
arb_clear(a);
arb_clear(b);
arb_clear(s);
arb_clear(t);
_arb_vec_clear(res, len);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
