/* x(x+1)...(x+7) = (28 + 98x + 63x^2 + 14x^3 + x^4)^2 - 16 (7+2x)^2 */
static void
rfac_eight(fmprb_t t, const fmprb_t x, long prec)
{
fmprb_t u, v;
fmprb_init(u);
fmprb_init(v);
/* t = x^2, v = x^3, u = x^4 */
fmprb_mul(t, x, x, prec);
fmprb_mul(v, x, t, prec);
fmprb_mul(u, t, t, prec);
/* u = (28 + ...)^2 */
fmprb_addmul_ui(u, v, 14UL, prec);
fmprb_addmul_ui(u, t, 63UL, prec);
fmprb_addmul_ui(u, x, 98UL, prec);
fmprb_add_ui(u, u, 28UL, prec);
fmprb_mul(u, u, u, prec);
/* 16 (7+2x)^2 = 784 + 448x + 64x^2 */
fmprb_sub_ui(u, u, 784UL, prec);
fmprb_submul_ui(u, x, 448UL, prec);
fmprb_mul_2exp_si(t, t, 6);
fmprb_sub(t, u, t, prec);
fmprb_clear(u);
fmprb_clear(v);
}
void
fmpcb_cos_pi(fmpcb_t r, const fmpcb_t z, long prec)
{
#define a fmpcb_realref(z)
#define b fmpcb_imagref(z)
fmprb_t sa, ca, sb, cb;
fmprb_init(sa);
fmprb_init(ca);
fmprb_init(sb);
fmprb_init(cb);
fmprb_sin_cos_pi(sa, ca, a, prec);
fmprb_const_pi(cb, prec);
fmprb_mul(cb, cb, b, prec);
fmprb_sinh_cosh(sb, cb, cb, prec);
fmprb_mul(fmpcb_realref(r), ca, cb, prec);
fmprb_mul(fmpcb_imagref(r), sa, sb, prec);
fmprb_neg(fmpcb_imagref(r), fmpcb_imagref(r));
fmprb_clear(sa);
fmprb_clear(ca);
fmprb_clear(sb);
fmprb_clear(cb);
#undef a
#undef b
}
void
_fmprb_poly_evaluate_rectangular(fmprb_t y, fmprb_srcptr poly,
long len, const fmprb_t x, long prec)
{
long i, j, m, r;
fmprb_ptr xs;
fmprb_t s, t, c;
if (len < 3)
{
if (len == 0)
{
fmprb_zero(y);
}
else if (len == 1)
{
fmprb_set_round(y, poly + 0, prec);
}
else if (len == 2)
{
fmprb_mul(y, x, poly + 1, prec);
fmprb_add(y, y, poly + 0, prec);
}
return;
}
m = n_sqrt(len) + 1;
r = (len + m - 1) / m;
xs = _fmprb_vec_init(m + 1);
fmprb_init(s);
fmprb_init(t);
fmprb_init(c);
_fmprb_vec_set_powers(xs, x, m + 1, prec);
fmprb_set(y, poly + (r - 1) * m);
for (j = 1; (r - 1) * m + j < len; j++)
fmprb_addmul(y, xs + j, poly + (r - 1) * m + j, prec);
for (i = r - 2; i >= 0; i--)
{
fmprb_set(s, poly + i * m);
for (j = 1; j < m; j++)
fmprb_addmul(s, xs + j, poly + i * m + j, prec);
fmprb_mul(y, y, xs + m, prec);
fmprb_add(y, y, s, prec);
}
_fmprb_vec_clear(xs, m + 1);
fmprb_clear(s);
fmprb_clear(t);
fmprb_clear(c);
}
void
bound_I(fmprb_ptr I, const fmprb_t A, const fmprb_t B, const fmprb_t C, long len, long wp)
{
long k;
fmprb_t D, Dk, L, T, Bm1;
fmprb_init(D);
fmprb_init(Dk);
fmprb_init(Bm1);
fmprb_init(T);
fmprb_init(L);
fmprb_sub_ui(Bm1, B, 1, wp);
fmprb_one(L);
/* T = 1 / (A^Bm1 * Bm1) */
fmprb_inv(T, A, wp);
fmprb_pow(T, T, Bm1, wp);
fmprb_div(T, T, Bm1, wp);
if (len > 1)
{
fmprb_log(D, A, wp);
fmprb_add(D, D, C, wp);
fmprb_mul(D, D, Bm1, wp);
fmprb_set(Dk, D);
}
for (k = 0; k < len; k++)
{
if (k > 0)
{
fmprb_mul_ui(L, L, k, wp);
fmprb_add(L, L, Dk, wp);
fmprb_mul(Dk, Dk, D, wp);
}
fmprb_mul(I + k, L, T, wp);
fmprb_div(T, T, Bm1, wp);
}
fmprb_clear(D);
fmprb_clear(Dk);
fmprb_clear(Bm1);
fmprb_clear(T);
fmprb_clear(L);
}
void
_fmprb_poly_tan_series(fmprb_ptr g,
fmprb_srcptr h, long hlen, long len, long prec)
{
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
fmprb_tan(g, h, prec);
_fmprb_vec_zero(g + 1, len - 1);
}
else if (len == 2)
{
fmprb_t t;
fmprb_init(t);
fmprb_tan(g, h, prec);
fmprb_mul(t, g, g, prec);
fmprb_add_ui(t, t, 1, prec);
fmprb_mul(g + 1, t, h + 1, prec); /* safe since hlen >= 2 */
fmprb_clear(t);
}
else
{
fmprb_ptr t, u;
t = _fmprb_vec_init(2 * len);
u = t + len;
NEWTON_INIT(TAN_NEWTON_CUTOFF, len)
NEWTON_BASECASE(n)
_fmprb_poly_sin_cos_series_basecase(t, u, h, hlen, n, prec);
_fmprb_poly_div_series(g, t, n, u, n, n, prec);
NEWTON_END_BASECASE
NEWTON_LOOP(m, n)
_fmprb_poly_mullow(u, g, m, g, m, n, prec);
fmprb_add_ui(u, u, 1, prec);
_fmprb_poly_atan_series(t, g, m, n, prec);
_fmprb_poly_sub(t + m, h + m, FLINT_MAX(0, hlen - m), t + m, n - m, prec);
_fmprb_poly_mullow(g + m, u, n, t + m, n - m, n - m, prec);
NEWTON_END_LOOP
NEWTON_END
_fmprb_vec_clear(t, 2 * len);
}
}
void
_fmprb_poly_mullow(fmprb_ptr res,
fmprb_srcptr poly1, long len1,
fmprb_srcptr poly2, long len2, long n, long prec)
{
if (n == 1)
{
fmprb_mul(res, poly1, poly2, prec);
}
else
{
#if 0
if (n < BLOCK_CUTOFF || len1 < BLOCK_CUTOFF || len2 < BLOCK_CUTOFF)
_fmprb_poly_mullow_classical(res, poly1, len1, poly2, len2, n, prec);
else if (n < SCALE_CUTOFF || len1 < SCALE_CUTOFF || len2 < SCALE_CUTOFF)
_fmprb_poly_mullow_block(res, poly1, len1, poly2, len2, n, prec);
else
_fmprb_poly_mullow_block_scaled(res, poly1, len1, poly2, len2, n, prec);
#else
if (n < BLOCK2_CUTOFF || len1 < BLOCK2_CUTOFF || len2 < BLOCK2_CUTOFF)
_fmprb_poly_mullow_classical(res, poly1, len1, poly2, len2, n, prec);
else
_fmprb_poly_mullow_block2(res, poly1, len1, poly2, len2, n, prec);
#endif
}
}
void
_fmprb_poly_product_roots(fmprb_ptr poly, fmprb_srcptr xs, long n, long prec)
{
if (n == 0)
{
fmprb_one(poly);
}
else if (n == 1)
{
fmprb_neg(poly, xs);
fmprb_one(poly + 1);
}
else if (n == 2)
{
fmprb_mul(poly, xs + 0, xs + 1, prec);
fmprb_add(poly + 1, xs + 0, xs + 1, prec);
fmprb_neg(poly + 1, poly + 1);
fmprb_one(poly + 2);
}
else
{
const long m = (n + 1) / 2;
fmprb_ptr tmp;
tmp = _fmprb_vec_init(n + 2);
_fmprb_poly_product_roots(tmp, xs, m, prec);
_fmprb_poly_product_roots(tmp + m + 1, xs + m, n - m, prec);
_fmprb_poly_mul_monic(poly, tmp, m + 1, tmp + m + 1, n - m + 1, prec);
_fmprb_vec_clear(tmp, n + 2);
}
}
void
fmprb_mat_det(fmprb_t det, const fmprb_mat_t A, long prec)
{
long n = fmprb_mat_nrows(A);
if (n == 0)
{
fmprb_one(det);
}
else if (n == 1)
{
fmprb_set(det, fmprb_mat_entry(A, 0, 0));
}
else if (n == 2)
{
fmprb_mul(det, fmprb_mat_entry(A, 0, 0), fmprb_mat_entry(A, 1, 1), prec);
fmprb_submul(det, fmprb_mat_entry(A, 0, 1), fmprb_mat_entry(A, 1, 0), prec);
}
else
{
fmprb_mat_t T;
fmprb_mat_init(T, fmprb_mat_nrows(A), fmprb_mat_ncols(A));
fmprb_mat_set(T, A);
fmprb_mat_det_inplace(det, T, prec);
fmprb_mat_clear(T);
}
}
void
_fmprb_poly_sin_series(fmprb_ptr g, fmprb_srcptr h, long hlen, long n, long prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
fmprb_sin(g, h, prec);
_fmprb_vec_zero(g + 1, n - 1);
}
else if (n == 2)
{
fmprb_t t;
fmprb_init(t);
fmprb_sin_cos(g, t, h, prec);
fmprb_mul(g + 1, h + 1, t, prec); /* safe since hlen >= 2 */
fmprb_clear(t);
}
else
{
fmprb_ptr t = _fmprb_vec_init(n);
_fmprb_poly_sin_cos_series(g, t, h, hlen, n, prec);
_fmprb_vec_clear(t, n);
}
}
void
zeta_ui_borwein_bsplit(fmprb_t x, ulong s, long prec)
{
zeta_bsplit_t sum;
fmpr_t err;
long wp, n;
/* zeta(0) = -1/2 */
if (s == 0)
{
fmpr_set_si_2exp_si(fmprb_midref(x), -1, -1);
fmpr_zero(fmprb_radref(x));
return;
}
if (s == 1)
{
printf("zeta_ui_borwein_bsplit: zeta(1)");
abort();
}
n = prec / ERROR_B + 2;
wp = prec + 30;
zeta_bsplit_init(sum);
zeta_bsplit(sum, 0, n + 1, n, s, 0, wp);
/* A/Q3 - B/Q3 / (C/Q1) = (A*C - B*Q1) / (Q3*C) */
fmprb_mul(sum->A, sum->A, sum->C, wp);
fmprb_mul(sum->B, sum->B, sum->Q1, wp);
fmprb_sub(sum->A, sum->A, sum->B, wp);
fmprb_mul(sum->Q3, sum->Q3, sum->C, wp);
fmprb_div(sum->C, sum->A, sum->Q3, wp);
fmpr_init(err);
borwein_error(err, n);
fmprb_add_error_fmpr(sum->C, err);
fmpr_clear(err);
/* convert from eta(s) to zeta(s) */
fmprb_div_2expm1_ui(x, sum->C, s - 1, wp);
fmprb_mul_2exp_si(x, x, s - 1);
zeta_bsplit_clear(sum);
}
void
bernoulli_rev_init(bernoulli_rev_t iter, ulong nmax)
{
long j;
fmpz_t t;
fmprb_t x;
int round1, round2;
long wp;
nmax -= (nmax % 2);
iter->n = nmax;
iter->alloc = 0;
if (nmax < BERNOULLI_REV_MIN)
return;
iter->prec = wp = global_prec(nmax);
iter->max_power = zeta_terms(nmax, iter->prec);
iter->alloc = iter->max_power + 1;
iter->powers = _fmpz_vec_init(iter->alloc);
fmpz_init(iter->pow_error);
fmprb_init(iter->prefactor);
fmprb_init(iter->two_pi_squared);
fmprb_init(x);
fmpz_init(t);
/* precompute powers */
for (j = 3; j <= iter->max_power; j += 2)
{
fmprb_ui_pow_ui(x, j, nmax, power_prec(j, nmax, wp));
fmprb_ui_div(x, 1UL, x, power_prec(j, nmax, wp));
round1 = fmpr_get_fmpz_fixed_si(t, fmprb_midref(x), -wp);
fmpz_set(iter->powers + j, t);
/* error: the radius, plus two roundings */
round2 = fmpr_get_fmpz_fixed_si(t, fmprb_radref(x), -wp);
fmpz_add_ui(t, t, (round1 != 0) + (round2 != 0));
if (fmpz_cmp(iter->pow_error, t) < 0)
fmpz_set(iter->pow_error, t);
}
/* precompute (2pi)^2 and 2*(n!)/(2pi)^n */
fmprb_fac_ui(iter->prefactor, nmax, wp);
fmprb_mul_2exp_si(iter->prefactor, iter->prefactor, 1);
fmprb_const_pi(x, wp);
fmprb_mul_2exp_si(x, x, 1);
fmprb_mul(iter->two_pi_squared, x, x, wp);
fmprb_pow_ui(x, iter->two_pi_squared, nmax / 2, wp);
fmprb_div(iter->prefactor, iter->prefactor, x, wp);
fmpz_clear(t);
fmprb_clear(x);
}
/* series of c^(d+x) */
static __inline__ void
_fmprb_poly_pow_cpx(fmprb_ptr res, const fmprb_t c, const fmprb_t d, long trunc, long prec)
{
long i;
fmprb_t logc;
fmprb_init(logc);
fmprb_log(logc, c, prec);
fmprb_mul(res + 0, logc, d, prec);
fmprb_exp(res + 0, res + 0, prec);
for (i = 1; i < trunc; i++)
{
fmprb_mul(res + i, res + i - 1, logc, prec);
fmprb_div_ui(res + i, res + i, i, prec);
}
fmprb_clear(logc);
}
/* 0.5*(B/AN)^2 + |B|/AN */
void
bound_C(fmprb_t C, const fmprb_t AN, const fmprb_t B, long wp)
{
fmprb_t t;
fmprb_init(t);
fmprb_abs(t, B);
fmprb_div(t, t, AN, wp);
fmprb_mul_2exp_si(C, t, -1);
fmprb_add_ui(C, C, 1, wp);
fmprb_mul(C, C, t, wp);
fmprb_clear(t);
}
void
fmprb_agm(fmprb_t z, const fmprb_t x, const fmprb_t y, long prec)
{
fmprb_t t, u, v, w;
if (fmprb_contains_negative(x) || fmprb_contains_negative(y))
{
fmprb_indeterminate(z);
return;
}
if (fmprb_is_zero(x) || fmprb_is_zero(y))
{
fmprb_zero(z);
return;
}
fmprb_init(t);
fmprb_init(u);
fmprb_init(v);
fmprb_init(w);
fmprb_set(t, x);
fmprb_set(u, y);
while (!fmprb_overlaps(t, u) &&
!fmprb_contains_nonpositive(t) &&
!fmprb_contains_nonpositive(u))
{
fmprb_add(v, t, u, prec);
fmprb_mul_2exp_si(v, v, -1);
fmprb_mul(w, t, u, prec);
fmprb_sqrt(w, w, prec);
fmprb_swap(v, t);
fmprb_swap(w, u);
}
if (!fmprb_is_finite(t) || !fmprb_is_finite(u))
{
fmprb_indeterminate(z);
}
else
{
fmprb_union(z, t, u, prec);
}
fmprb_clear(t);
fmprb_clear(u);
fmprb_clear(v);
fmprb_clear(w);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rsqrt....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b, c;
slong prec = 2 + n_randint(state, 200);
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
fmprb_randtest(a, state, 1 + n_randint(state, 200), 10);
fmprb_rsqrt(b, a, prec);
fmprb_inv(c, b, prec);
fmprb_mul(c, c, c, prec);
if (!fmprb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); fmprb_print(a); flint_printf("\n\n");
flint_printf("b = "); fmprb_print(b); flint_printf("\n\n");
flint_printf("c = "); fmprb_print(c); flint_printf("\n\n");
abort();
}
fmprb_rsqrt(a, a, prec);
if (!fmprb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
fmprb_mat_det_inplace(fmprb_t det, fmprb_mat_t A, long prec)
{
long i, n, sign, rank;
n = fmprb_mat_nrows(A);
rank = fmprb_mat_gauss_partial(A, prec);
sign = (rank < 0) ? -1 : 1;
rank = FLINT_ABS(rank);
fmprb_set_si(det, sign);
for (i = 0; i < rank; i++)
fmprb_mul(det, det, fmprb_mat_entry(A, i, i), prec);
/* bound unreduced part using Hadamard's inequality */
if (rank < n)
{
fmpr_t t;
fmprb_t d;
fmpr_init(t);
fmprb_init(d);
fmpr_one(fmprb_radref(d));
for (i = rank; i < n; i++)
{
fmprb_vec_get_fmpr_2norm_squared_bound(t, A->rows[i] + rank,
n - rank, FMPRB_RAD_PREC);
fmpr_mul(fmprb_radref(d), fmprb_radref(d), t, FMPRB_RAD_PREC, FMPR_RND_UP);
}
fmpr_sqrt(fmprb_radref(d), fmprb_radref(d), FMPRB_RAD_PREC, FMPR_RND_UP);
fmprb_mul(det, det, d, prec);
fmprb_clear(d);
fmpr_clear(t);
}
}
void
_fmprb_poly_evaluate_horner(fmprb_t y, fmprb_srcptr f, long len,
const fmprb_t x, long prec)
{
if (len == 0)
{
fmprb_zero(y);
}
else if (len == 1 || fmprb_is_zero(x))
{
fmprb_set_round(y, f, prec);
}
else if (len == 2)
{
fmprb_mul(y, x, f + 1, prec);
fmprb_add(y, y, f + 0, prec);
}
else
{
long i = len - 1;
fmprb_t t, u;
fmprb_init(t);
fmprb_init(u);
fmprb_set(u, f + i);
for (i = len - 2; i >= 0; i--)
{
fmprb_mul(t, u, x, prec);
fmprb_add(u, f + i, t, prec);
}
fmprb_swap(y, u);
fmprb_clear(t);
fmprb_clear(u);
}
}
/* This gives some speedup for small lengths. */
static __inline__ void
_fmprb_poly_rem_2(fmprb_ptr r, fmprb_srcptr a, long al,
fmprb_srcptr b, long bl, long prec)
{
if (al == 2)
{
fmprb_mul(r + 0, a + 1, b + 0, prec);
fmprb_sub(r + 0, a + 0, r + 0, prec);
}
else
{
_fmprb_poly_rem(r, a, al, b, bl, prec);
}
}
static __inline__ void
zeta_coeff_k(zeta_bsplit_t S, long k, long n, long s)
{
fmprb_set_si(S->D, 2 * (n + k));
fmprb_mul_si(S->D, S->D, n - k, FMPR_PREC_EXACT);
fmprb_set_si(S->Q1, k + 1);
fmprb_mul_si(S->Q1, S->Q1, 2*k + 1, FMPR_PREC_EXACT);
if (k == 0)
{
fmprb_zero(S->A);
fmprb_one(S->Q2);
}
else
{
fmprb_set_si(S->A, k % 2 ? 1 : -1);
fmprb_mul(S->A, S->A, S->Q1, FMPR_PREC_EXACT);
fmprb_ui_pow_ui(S->Q2, k, s, FMPR_PREC_EXACT);
}
fmprb_mul(S->Q3, S->Q1, S->Q2, FMPR_PREC_EXACT);
fmprb_zero(S->B);
fmprb_set(S->C, S->Q1);
}
static void
zeta_bsplit(zeta_bsplit_t L, long a, long b,
long n, long s, int cont, long bits)
{
if (a + 1 == b)
{
zeta_coeff_k(L, a, n, s);
}
else
{
zeta_bsplit_t R;
long m = (a + b) / 2;
zeta_bsplit(L, m, b, n, s, 1, bits);
zeta_bsplit_init(R);
zeta_bsplit(R, a, m, n, s, 1, bits);
fmprb_mul(L->B, L->B, R->D, bits);
fmprb_addmul(L->B, L->A, R->C, bits);
fmprb_mul(L->B, L->B, R->Q2, bits);
fmprb_addmul(L->B, R->B, L->Q3, bits);
fmprb_mul(L->A, L->A, R->Q3, bits);
fmprb_addmul(L->A, R->A, L->Q3, bits);
fmprb_mul(L->C, L->C, R->D, bits);
fmprb_addmul(L->C, R->C, L->Q1, bits);
if (cont)
{
fmprb_mul(L->D, L->D, R->D, bits);
fmprb_mul(L->Q2, L->Q2, R->Q2, bits);
}
fmprb_mul(L->Q1, L->Q1, R->Q1, bits);
fmprb_mul(L->Q3, L->Q3, R->Q3, bits);
zeta_bsplit_clear(R);
}
}
void
gamma_rising_fmprb_ui_bsplit_eight(fmprb_t y, const fmprb_t x, ulong n, long prec)
{
if (n == 0)
{
fmprb_one(y);
}
else if (n == 1)
{
fmprb_set_round(y, x, prec);
}
else
{
ulong k, a;
long wp;
fmprb_t t, u;
wp = FMPR_PREC_ADD(prec, FLINT_BIT_COUNT(n));
fmprb_init(t);
fmprb_init(u);
if (n >= 8)
{
bsplit(t, x, 0, (n / 8) * 8, wp);
a = (n / 8) * 8;
}
else
{
fmprb_set(t, x);
a = 1;
}
for (k = a; k < n; k++)
{
fmprb_add_ui(u, x, k, wp);
fmprb_mul(t, t, u, wp);
}
fmprb_set_round(y, t, prec);
fmprb_clear(t);
fmprb_clear(u);
}
}
void
bound_K(fmprb_t C, const fmprb_t AN, const fmprb_t B, const fmprb_t T, long wp)
{
if (fmprb_is_zero(B) || fmprb_is_zero(T))
{
fmprb_one(C);
}
else
{
fmprb_div(C, B, AN, wp);
/* TODO: atan is dumb, should also bound by pi/2 */
fmprb_atan(C, C, wp);
fmprb_mul(C, C, T, wp);
if (fmprb_is_nonpositive(C))
fmprb_one(C);
else
fmprb_exp(C, C, wp);
}
}
void
arb_mul_naive(arb_t z, const arb_t x, const arb_t y, slong prec)
{
fmprb_t c, a, b;
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
arb_get_fmprb(a, x);
arb_get_fmprb(b, y);
fmprb_mul(c, a, b, prec);
arb_set_fmprb(z, c);
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
}
void
fmprb_hypgeom_sum(fmprb_t P, fmprb_t Q, const hypgeom_t hyp, long n, long prec)
{
if (n < 1)
{
fmprb_zero(P);
fmprb_one(Q);
}
else
{
fmprb_t B, T;
fmprb_init(B);
fmprb_init(T);
bsplit_recursive_fmprb(P, Q, B, T, hyp, 0, n, 0, prec);
if (!fmprb_is_one(B))
fmprb_mul(Q, Q, B, prec);
fmprb_swap(P, T);
fmprb_clear(B);
fmprb_clear(T);
}
}
/* assumes y and x not aliased, the length is a positive multiple of 8 */
static void
bsplit(fmprb_t y, const fmprb_t x, ulong a, ulong b, long prec)
{
fmprb_t t;
fmprb_init(t);
if (b - a == 8)
{
fmprb_add_ui(t, x, a, prec);
rfac_eight(y, t, prec);
}
else
{
ulong m = a + ((b - a) / 16) * 8;
bsplit(y, x, a, m, prec);
bsplit(t, x, m, b, prec);
fmprb_mul(y, y, t, prec);
}
fmprb_clear(t);
}
void
_fmprb_poly_zeta_series(fmprb_ptr res, fmprb_srcptr h, long hlen, const fmprb_t a, int deflate, long len, long prec)
{
long i;
fmpcb_t cs, ca;
fmpcb_ptr z;
fmprb_ptr t, u;
if (fmprb_contains_nonpositive(a))
{
_fmprb_vec_indeterminate(res, len);
return;
}
hlen = FLINT_MIN(hlen, len);
z = _fmpcb_vec_init(len);
t = _fmprb_vec_init(len);
u = _fmprb_vec_init(len);
fmpcb_init(cs);
fmpcb_init(ca);
/* use reflection formula */
if (fmpr_sgn(fmprb_midref(h)) < 0 && fmprb_is_one(a))
{
/* zeta(s) = (2*pi)**s * sin(pi*s/2) / pi * gamma(1-s) * zeta(1-s) */
fmprb_t pi;
fmprb_ptr f, s1, s2, s3, s4;
fmprb_init(pi);
f = _fmprb_vec_init(2);
s1 = _fmprb_vec_init(len);
s2 = _fmprb_vec_init(len);
s3 = _fmprb_vec_init(len);
s4 = _fmprb_vec_init(len);
fmprb_const_pi(pi, prec);
/* s1 = (2*pi)**s */
fmprb_mul_2exp_si(pi, pi, 1);
_fmprb_poly_pow_cpx(s1, pi, h, len, prec);
fmprb_mul_2exp_si(pi, pi, -1);
/* s2 = sin(pi*s/2) / pi */
fmprb_mul_2exp_si(pi, pi, -1);
fmprb_mul(f, pi, h, prec);
fmprb_set(f + 1, pi);
fmprb_mul_2exp_si(pi, pi, 1);
_fmprb_poly_sin_series(s2, f, 2, len, prec);
_fmprb_vec_scalar_div(s2, s2, len, pi, prec);
/* s3 = gamma(1-s) */
fmprb_sub_ui(f, h, 1, prec);
fmprb_neg(f, f);
fmprb_set_si(f + 1, -1);
_fmprb_poly_gamma_series(s3, f, 2, len, prec);
/* s4 = zeta(1-s) */
fmprb_sub_ui(f, h, 1, prec);
fmprb_neg(f, f);
fmpcb_set_fmprb(cs, f);
fmpcb_one(ca);
zeta_series(z, cs, ca, 0, len, prec);
for (i = 0; i < len; i++)
fmprb_set(s4 + i, fmpcb_realref(z + i));
for (i = 1; i < len; i += 2)
fmprb_neg(s4 + i, s4 + i);
_fmprb_poly_mullow(u, s1, len, s2, len, len, prec);
_fmprb_poly_mullow(s1, s3, len, s4, len, len, prec);
_fmprb_poly_mullow(t, u, len, s1, len, len, prec);
/* add 1/(1-(s+t)) = 1/(1-s) + t/(1-s)^2 + ... */
if (deflate)
{
fmprb_sub_ui(u, h, 1, prec);
fmprb_neg(u, u);
fmprb_ui_div(u, 1, u, prec);
for (i = 1; i < len; i++)
fmprb_mul(u + i, u + i - 1, u, prec);
_fmprb_vec_add(t, t, u, len, prec);
}
fmprb_clear(pi);
_fmprb_vec_clear(f, 2);
_fmprb_vec_clear(s1, len);
_fmprb_vec_clear(s2, len);
_fmprb_vec_clear(s3, len);
_fmprb_vec_clear(s4, len);
}
else
{
fmpcb_set_fmprb(cs, h);
fmpcb_set_fmprb(ca, a);
zeta_series(z, cs, ca, deflate, len, prec);
for (i = 0; i < len; i++)
fmprb_set(t + i, fmpcb_realref(z + i));
}
/* compose with nonconstant part */
fmprb_zero(u);
_fmprb_vec_set(u + 1, h + 1, hlen - 1);
_fmprb_poly_compose_series(res, t, len, u, hlen, len, prec);
_fmpcb_vec_clear(z, len);
_fmprb_vec_clear(t, len);
_fmprb_vec_clear(u, len);
fmpcb_init(cs);
fmpcb_init(ca);
}
int main()
{
long iter;
flint_rand_t state;
printf("exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b;
fmpq_t q;
mpfr_t t;
long prec = 2 + n_randint(state, 200);
fmprb_init(a);
fmprb_init(b);
fmpq_init(q);
mpfr_init2(t, prec + 100);
fmprb_randtest(a, state, 1 + n_randint(state, 200), 3);
fmprb_randtest(b, state, 1 + n_randint(state, 200), 3);
fmprb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
mpfr_exp(t, t, MPFR_RNDN);
fmprb_exp(b, a, prec);
if (!fmprb_contains_mpfr(b, t))
{
printf("FAIL: containment\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
abort();
}
fmprb_exp(a, a, prec);
if (!fmprb_equal(a, b))
{
printf("FAIL: aliasing\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* check large arguments */
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b, c, d;
long prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
fmprb_init(d);
fmprb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100);
fmprb_exp(b, a, prec1);
fmprb_exp(c, a, prec2);
if (!fmprb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
abort();
}
fmprb_randtest_precise(b, state, 1 + n_randint(state, 1000), 100);
/* check exp(a)*exp(b) = exp(a+b) */
fmprb_exp(c, a, prec1);
fmprb_exp(d, b, prec1);
fmprb_mul(c, c, d, prec1);
fmprb_add(d, a, b, prec1);
fmprb_exp(d, d, prec1);
if (!fmprb_overlaps(c, d))
{
printf("FAIL: functional equation\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
printf("d = "); fmprb_print(d); printf("\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
fmprb_clear(d);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
gamma_stirling_eval_fmprb(fmprb_t s, const fmprb_t z, long nterms, int digamma, long prec)
{
fmprb_t b, t, logz, zinv, zinv2;
fmpr_t err;
long k, term_prec;
double z_mag, term_mag;
fmprb_init(b);
fmprb_init(t);
fmprb_init(logz);
fmprb_init(zinv);
fmprb_init(zinv2);
fmprb_log(logz, z, prec);
fmprb_ui_div(zinv, 1UL, z, prec);
nterms = FLINT_MAX(nterms, 1);
fmprb_zero(s);
if (nterms > 1)
{
fmprb_mul(zinv2, zinv, zinv, prec);
z_mag = fmpr_get_d(fmprb_midref(logz), FMPR_RND_UP) * 1.44269504088896;
for (k = nterms - 1; k >= 1; k--)
{
term_mag = bernoulli_bound_2exp_si(2 * k);
term_mag -= (2 * k - 1) * z_mag;
term_prec = prec + term_mag;
term_prec = FLINT_MIN(term_prec, prec);
term_prec = FLINT_MAX(term_prec, 10);
if (prec > 2000)
{
fmprb_set_round(t, zinv2, term_prec);
fmprb_mul(s, s, t, term_prec);
}
else
fmprb_mul(s, s, zinv2, term_prec);
gamma_stirling_coeff(b, k, digamma, term_prec);
fmprb_add(s, s, b, term_prec);
}
if (digamma)
fmprb_mul(s, s, zinv2, prec);
else
fmprb_mul(s, s, zinv, prec);
}
/* remainder bound */
fmpr_init(err);
gamma_stirling_bound_fmprb(err, z, digamma ? 1 : 0, 1, nterms);
fmprb_add_error_fmpr(s, err);
fmpr_clear(err);
if (digamma)
{
fmprb_neg(s, s);
fmprb_mul_2exp_si(zinv, zinv, -1);
fmprb_sub(s, s, zinv, prec);
fmprb_add(s, s, logz, prec);
}
else
{
/* (z-0.5)*log(z) - z + log(2*pi)/2 */
fmprb_one(t);
fmprb_mul_2exp_si(t, t, -1);
fmprb_sub(t, z, t, prec);
fmprb_mul(t, logz, t, prec);
fmprb_add(s, s, t, prec);
fmprb_sub(s, s, z, prec);
fmprb_const_log_sqrt2pi(t, prec);
fmprb_add(s, s, t, prec);
}
fmprb_clear(t);
fmprb_clear(b);
fmprb_clear(zinv);
fmprb_clear(zinv2);
fmprb_clear(logz);
}
void
fmpcb_calc_cauchy_bound(fmprb_t bound, fmpcb_calc_func_t func, void * param,
const fmpcb_t x, const fmprb_t radius, long maxdepth, long prec)
{
long i, n, depth, wp;
fmprb_t pi, theta, v, s1, c1, s2, c2, st, ct;
fmpcb_t t, u;
fmprb_t b;
fmprb_init(pi);
fmprb_init(theta);
fmprb_init(v);
fmprb_init(s1);
fmprb_init(c1);
fmprb_init(s2);
fmprb_init(c2);
fmprb_init(st);
fmprb_init(ct);
fmpcb_init(t);
fmpcb_init(u);
fmprb_init(b);
wp = prec + 20;
fmprb_const_pi(pi, wp);
fmprb_zero_pm_inf(b);
for (depth = 0, n = 16; depth < maxdepth; n *= 2, depth++)
{
fmprb_zero(b);
/* theta = 2 pi / n */
fmprb_div_ui(theta, pi, n, wp);
fmprb_mul_2exp_si(theta, theta, 1);
/* sine and cosine of i*theta and (i+1)*theta */
fmprb_zero(s1);
fmprb_one(c1);
fmprb_sin_cos(st, ct, theta, wp);
fmprb_set(s2, st);
fmprb_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 */
fmprb_union(fmpcb_realref(t), c1, c2, wp);
fmprb_union(fmpcb_imagref(t), s1, s2, wp);
fmpcb_mul_fmprb(t, t, radius, wp);
fmpcb_add(t, t, x, prec);
/* next angle */
fmprb_mul(v, c2, ct, wp);
fmprb_mul(c1, s2, st, wp);
fmprb_sub(c1, v, c1, wp);
fmprb_mul(v, c2, st, wp);
fmprb_mul(s1, s2, ct, wp);
fmprb_add(s1, v, s1, wp);
fmprb_swap(c1, c2);
fmprb_swap(s1, s2);
func(u, t, param, 1, prec);
fmpcb_abs(v, u, prec);
fmprb_add(b, b, v, prec);
}
fmprb_div_ui(b, b, n, prec);
if (fmprb_is_exact(b) || fmpr_cmp(fmprb_radref(b), fmprb_midref(b)) < 0)
break;
}
fmprb_set(bound, b);
fmprb_clear(pi);
fmprb_clear(theta);
fmprb_clear(v);
fmpcb_clear(t);
fmpcb_clear(u);
fmprb_clear(b);
fmprb_clear(s1);
fmprb_clear(c1);
fmprb_clear(s2);
fmprb_clear(c2);
fmprb_clear(st);
fmprb_clear(ct);
}
void
zeta_series_em_vec_bound(fmprb_ptr bound, const fmpcb_t s, const fmpcb_t a, ulong N, ulong M, long len, long wp)
{
fmprb_t K, C, AN, S2M;
fmprb_ptr F, R;
long k;
fmprb_srcptr alpha = fmpcb_realref(a);
fmprb_srcptr beta = fmpcb_imagref(a);
fmprb_srcptr sigma = fmpcb_realref(s);
fmprb_srcptr tau = fmpcb_imagref(s);
fmprb_init(AN);
fmprb_init(S2M);
/* require alpha + N > 1, sigma + 2M > 1 */
fmprb_add_ui(AN, alpha, N - 1, wp);
fmprb_add_ui(S2M, sigma, 2*M - 1, wp);
if (!fmprb_is_positive(AN) || !fmprb_is_positive(S2M) || N < 1 || M < 1)
{
fmprb_clear(AN);
fmprb_clear(S2M);
for (k = 0; k < len; k++)
{
fmpr_pos_inf(fmprb_midref(bound + k));
fmpr_zero(fmprb_radref(bound + k));
}
return;
}
/* alpha + N, sigma + 2M */
fmprb_add_ui(AN, AN, 1, wp);
fmprb_add_ui(S2M, S2M, 1, wp);
R = _fmprb_vec_init(len);
F = _fmprb_vec_init(len);
fmprb_init(K);
fmprb_init(C);
/* bound for power integral */
bound_C(C, AN, beta, wp);
bound_K(K, AN, beta, tau, wp);
bound_I(R, AN, S2M, C, len, wp);
for (k = 0; k < len; k++)
{
fmprb_mul(R + k, R + k, K, wp);
fmprb_div_ui(K, K, k + 1, wp);
}
/* bound for rising factorial */
bound_rfac(F, s, 2*M, len, wp);
/* product (TODO: only need upper bound; write a function for this) */
_fmprb_poly_mullow(bound, F, len, R, len, len, wp);
/* bound for bernoulli polynomials, 4 / (2pi)^(2M) */
fmprb_const_pi(C, wp);
fmprb_mul_2exp_si(C, C, 1);
fmprb_pow_ui(C, C, 2 * M, wp);
fmprb_ui_div(C, 4, C, wp);
_fmprb_vec_scalar_mul(bound, bound, len, C, wp);
fmprb_clear(K);
fmprb_clear(C);
fmprb_clear(AN);
fmprb_clear(S2M);
_fmprb_vec_clear(R, len);
_fmprb_vec_clear(F, len);
}
