void
_acb_dirichlet_hardy_z_series(acb_ptr res, acb_srcptr s, slong slen,
const dirichlet_group_t G, const dirichlet_char_t chi,
slong len, slong prec)
{
slen = FLINT_MIN(slen, len);
if (len == 0)
return;
if (slen == 1)
{
acb_dirichlet_hardy_z(res, s, G, chi, 1, prec);
_acb_vec_zero(res + 1, len - 1);
}
else
{
acb_ptr t, u;
t = _acb_vec_init(len);
u = _acb_vec_init(slen);
acb_dirichlet_hardy_z(t, s, G, chi, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, s + 1, slen - 1);
_acb_poly_compose_series(res, t, len, u, slen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, slen);
}
}
void
_acb_poly_revert_series_lagrange_fast(acb_ptr Qinv, acb_srcptr Q, slong Qlen, slong n, slong prec)
{
slong i, j, k, m;
acb_ptr R, S, T, tmp;
acb_t t;
if (n <= 2)
{
if (n >= 1)
acb_zero(Qinv);
if (n == 2)
acb_inv(Qinv + 1, Q + 1, prec);
return;
}
m = n_sqrt(n);
acb_init(t);
R = _acb_vec_init((n - 1) * m);
S = _acb_vec_init(n - 1);
T = _acb_vec_init(n - 1);
acb_zero(Qinv);
acb_inv(Qinv + 1, Q + 1, prec);
_acb_poly_inv_series(Ri(1), Q + 1, FLINT_MIN(Qlen, n) - 1, n - 1, prec);
for (i = 2; i <= m; i++)
_acb_poly_mullow(Ri(i), Ri((i + 1) / 2), n - 1, Ri(i / 2), n - 1, n - 1, prec);
for (i = 2; i < m; i++)
acb_div_ui(Qinv + i, Ri(i) + i - 1, i, prec);
_acb_vec_set(S, Ri(m), n - 1);
for (i = m; i < n; i += m)
{
acb_div_ui(Qinv + i, S + i - 1, i, prec);
for (j = 1; j < m && i + j < n; j++)
{
acb_mul(t, S + 0, Ri(j) + i + j - 1, prec);
for (k = 1; k <= i + j - 1; k++)
acb_addmul(t, S + k, Ri(j) + i + j - 1 - k, prec);
acb_div_ui(Qinv + i + j, t, i + j, prec);
}
if (i + 1 < n)
{
_acb_poly_mullow(T, S, n - 1, Ri(m), n - 1, n - 1, prec);
tmp = S; S = T; T = tmp;
}
}
acb_clear(t);
_acb_vec_clear(R, (n - 1) * m);
_acb_vec_clear(S, n - 1);
_acb_vec_clear(T, n - 1);
}
void
_acb_hypgeom_coulomb_series(acb_ptr F, acb_ptr G,
acb_ptr Hpos, acb_ptr Hneg, const acb_t l, const acb_t eta,
acb_srcptr z, slong zlen, slong len, slong prec)
{
acb_ptr t, v;
if (len == 0)
return;
zlen = FLINT_MIN(zlen, len);
if (zlen == 1)
{
acb_hypgeom_coulomb(F, G, Hpos, Hneg, l, eta, z, prec);
if (F != NULL) _acb_vec_zero(F + 1, len - 1);
if (G != NULL) _acb_vec_zero(G + 1, len - 1);
if (Hpos != NULL) _acb_vec_zero(Hpos + 1, len - 1);
if (Hneg != NULL) _acb_vec_zero(Hneg + 1, len - 1);
return;
}
t = _acb_vec_init(len);
v = _acb_vec_init(zlen);
/* copy nonconstant part first to allow aliasing */
acb_zero(v);
_acb_vec_set(v + 1, z + 1, zlen - 1);
acb_hypgeom_coulomb_jet(F, G, Hpos, Hneg, l, eta, z, len, prec);
if (F != NULL)
{
_acb_vec_set(t, F, len);
_acb_poly_compose_series(F, t, len, v, zlen, len, prec);
}
if (G != NULL)
{
_acb_vec_set(t, G, len);
_acb_poly_compose_series(G, t, len, v, zlen, len, prec);
}
if (Hpos != NULL)
{
_acb_vec_set(t, Hpos, len);
_acb_poly_compose_series(Hpos, t, len, v, zlen, len, prec);
}
if (Hneg != NULL)
{
_acb_vec_set(t, Hneg, len);
_acb_poly_compose_series(Hneg, t, len, v, zlen, len, prec);
}
_acb_vec_clear(t, len);
_acb_vec_clear(v, zlen);
}
void
_acb_poly_compose_series_brent_kung(acb_ptr res,
acb_srcptr poly1, long len1,
acb_srcptr poly2, long len2, long n, long prec)
{
acb_mat_t A, B, C;
acb_ptr t, h;
long i, m;
if (n == 1)
{
acb_set(res, poly1);
return;
}
m = n_sqrt(n) + 1;
acb_mat_init(A, m, n);
acb_mat_init(B, m, m);
acb_mat_init(C, m, n);
h = _acb_vec_init(n);
t = _acb_vec_init(n);
/* Set rows of B to the segments of poly1 */
for (i = 0; i < len1 / m; i++)
_acb_vec_set(B->rows[i], poly1 + i*m, m);
_acb_vec_set(B->rows[i], poly1 + i*m, len1 % m);
/* Set rows of A to powers of poly2 */
acb_set_ui(A->rows[0] + 0, 1UL);
_acb_vec_set(A->rows[1], poly2, len2);
for (i = 2; i < m; i++)
_acb_poly_mullow(A->rows[i], A->rows[(i + 1) / 2], n, A->rows[i / 2], n, n, prec);
acb_mat_mul(C, B, A, prec);
/* Evaluate block composition using the Horner scheme */
_acb_vec_set(res, C->rows[m - 1], n);
_acb_poly_mullow(h, A->rows[m - 1], n, poly2, len2, n, prec);
for (i = m - 2; i >= 0; i--)
{
_acb_poly_mullow(t, res, n, h, n, n, prec);
_acb_poly_add(res, t, n, C->rows[i], n, prec);
}
_acb_vec_clear(h, n);
_acb_vec_clear(t, n);
acb_mat_clear(A);
acb_mat_clear(B);
acb_mat_clear(C);
}
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);
}
int
bessel(acb_ptr out, const acb_t inp, void * params, long order, long prec)
{
acb_ptr t;
acb_t z;
ulong n;
t = _acb_vec_init(order);
acb_init(z);
acb_set(t, inp);
if (order > 1)
acb_one(t + 1);
n = 10;
arb_set_si(acb_realref(z), 20);
arb_set_si(acb_imagref(z), 10);
/* z sin(t) */
_acb_poly_sin_series(out, t, FLINT_MIN(2, order), order, prec);
_acb_vec_scalar_mul(out, out, order, z, prec);
/* t n */
_acb_vec_scalar_mul_ui(t, t, FLINT_MIN(2, order), n, prec);
_acb_poly_sub(out, t, FLINT_MIN(2, order), out, order, prec);
_acb_poly_cos_series(out, out, order, order, prec);
_acb_vec_clear(t, order);
acb_clear(z);
return 0;
}
void
_acb_poly_sin_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
acb_sin(g, h, prec);
_acb_vec_zero(g + 1, n - 1);
}
else if (n == 2)
{
acb_t t;
acb_init(t);
acb_sin_cos(g, t, h, prec);
acb_mul(g + 1, h + 1, t, prec); /* safe since hlen >= 2 */
acb_clear(t);
}
else
{
acb_ptr t = _acb_vec_init(n);
_acb_poly_sin_cos_series(g, t, h, hlen, n, prec);
_acb_vec_clear(t, n);
}
}
void
_acb_poly_interpolation_weights(acb_ptr w,
acb_ptr * tree, slong len, slong prec)
{
acb_ptr tmp;
slong i, n, height;
if (len == 0)
return;
if (len == 1)
{
acb_one(w);
return;
}
tmp = _acb_vec_init(len + 1);
height = FLINT_CLOG2(len);
n = WORD(1) << (height - 1);
_acb_poly_mul_monic(tmp, tree[height-1], n + 1,
tree[height-1] + (n + 1), (len - n + 1), prec);
_acb_poly_derivative(tmp, tmp, len + 1, prec);
_acb_poly_evaluate_vec_fast_precomp(w, tmp, len, tree, len, prec);
for (i = 0; i < len; i++)
acb_inv(w + i, w + i, prec);
_acb_vec_clear(tmp, len + 1);
}
int main() {
#define ni 5
slong n, i, f;
double b[ni][2] = { { 0, 1}, {-1, 1}, {0, 10}, {-20, 3}, {0, 3.14} };
const slong prec = 40;
#define nf 5
arb_func_t func[nf] = { (arb_func_t)&f_1x2, (arb_func_t)&f_pol, (arb_func_t)&f_thsh, (arb_func_t)&f_thsh_shift, (arb_func_t)&f_aj };
#if VERBOSE
char * fn[nf] = { "1/(1+x^2)", "1/p(x)", "th(sh(x))", "th(sh(x+.7I))" , "1/y" };
#endif
params_t p[nf];
arf_t tmin, tmax;
mag_t max;
flint_printf("max_func...");
fflush(stdout);
p[1].len = 3;
p[1].z = _acb_vec_init(3);
acb_set_d_d(p[1].z + 0, 2, 1);
acb_set_d_d(p[1].z + 1, 2, .1);
acb_set_d_d(p[1].z + 2, 1, .1);
p[4] = p[1];
arf_init(tmin);
arf_init(tmax);
mag_init(max);
for (i = 0; i < ni; i++)
{
arf_set_d(tmin, b[i][0]);
arf_set_d(tmax, b[i][1]);
for (f = 0; f < nf; f++)
{
for (n = 5; n < 100; n *= 2)
{
slong count;
count = mag_func_arf(max, func[f], (void *)&p[f], tmin, tmax, n, prec);
#if VERBOSE
flint_printf("\nmax %s on [%lf, %lf] <= ",fn[f],b[i][0],b[i][1]);
mag_printd(max,8);
flint_printf(" [asked %ld, did %ld]", n, count);
#endif
}
}
}
mag_clear(max);
arf_clear(tmin);
arf_clear(tmax);
printf("PASS\n");
return 0;
}
void
_acb_poly_interpolate_fast_precomp(acb_ptr poly,
acb_srcptr ys, acb_ptr * tree, acb_srcptr weights,
slong len, slong prec)
{
acb_ptr t, u, pa, pb;
slong i, pow, left;
if (len == 0)
return;
t = _acb_vec_init(len);
u = _acb_vec_init(len);
for (i = 0; i < len; i++)
acb_mul(poly + i, weights + i, ys + i, prec);
for (i = 0; i < FLINT_CLOG2(len); i++)
{
pow = (WORD(1) << i);
pa = tree[i];
pb = poly;
left = len;
while (left >= 2 * pow)
{
_acb_poly_mul(t, pa, pow + 1, pb + pow, pow, prec);
_acb_poly_mul(u, pa + pow + 1, pow + 1, pb, pow, prec);
_acb_vec_add(pb, t, u, 2 * pow, prec);
left -= 2 * pow;
pa += 2 * pow + 2;
pb += 2 * pow;
}
if (left > pow)
{
_acb_poly_mul(t, pa, pow + 1, pb + pow, left - pow, prec);
_acb_poly_mul(u, pb, pow, pa + pow + 1, left - pow + 1, prec);
_acb_vec_add(pb, t, u, left, prec);
}
}
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
void
_acb_poly_zeta_series(acb_ptr res, acb_srcptr h, slong hlen, const acb_t a, int deflate, slong len, slong prec)
{
acb_ptr t, u;
hlen = FLINT_MIN(hlen, len);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
_acb_poly_zeta_cpx_reflect(t, h, a, deflate, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, t, len, u, hlen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
void
_acb_poly_evaluate_rectangular(acb_t y, acb_srcptr poly,
slong len, const acb_t x, slong prec)
{
slong i, j, m, r;
acb_ptr xs;
acb_t s, t, c;
if (len < 3)
{
if (len == 0)
{
acb_zero(y);
}
else if (len == 1)
{
acb_set_round(y, poly + 0, prec);
}
else if (len == 2)
{
acb_mul(y, x, poly + 1, prec);
acb_add(y, y, poly + 0, prec);
}
return;
}
m = n_sqrt(len) + 1;
r = (len + m - 1) / m;
xs = _acb_vec_init(m + 1);
acb_init(s);
acb_init(t);
acb_init(c);
_acb_vec_set_powers(xs, x, m + 1, prec);
acb_set(y, poly + (r - 1) * m);
for (j = 1; (r - 1) * m + j < len; j++)
acb_addmul(y, xs + j, poly + (r - 1) * m + j, prec);
for (i = r - 2; i >= 0; i--)
{
acb_set(s, poly + i * m);
for (j = 1; j < m; j++)
acb_addmul(s, xs + j, poly + i * m + j, prec);
acb_mul(y, y, xs + m, prec);
acb_add(y, y, s, prec);
}
_acb_vec_clear(xs, m + 1);
acb_clear(s);
acb_clear(t);
acb_clear(c);
}
void
_acb_poly_agm1_series(acb_ptr res, acb_srcptr z, long zlen, long len, long prec)
{
acb_ptr t, u;
zlen = FLINT_MIN(zlen, len);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
acb_agm1_cpx(t, z, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, z + 1, zlen - 1);
_acb_poly_compose_series(res, t, len, u, zlen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
int main() {
slong n, i, m, prec = 60;
flint_rand_t state;
flint_printf("symplectic basis...");
fflush(stdout);
flint_randinit(state);
for (n = 3; n < 10; n++)
{
for (i = 0; i < 5; i++)
{
acb_ptr x;
tree_t tree;
x = _acb_vec_init(n);
acb_vec_set_random(x, n, state, prec, 4);
tree_init(tree, n - 1);
spanning_tree(tree, x, n, INT_DE);
for (m = 2; m < 7; m++)
{
sec_t c;
homol_t alpha, beta;
sec_init(&c, m, n);
tree_ydata_init(tree, x, n, m, prec);
alpha = flint_malloc(c.g * sizeof(loop_t));
beta = flint_malloc(c.g * sizeof(loop_t));
symplectic_basis(alpha, beta, tree, c);
homol_clear(alpha, c.g);
homol_clear(beta, c.g);
tree_ydata_clear(tree);
sec_clear(c);
}
tree_clear(tree);
_acb_vec_clear(x, n);
}
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return 0;
}
void
_acb_poly_atan_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
acb_t c;
acb_init(c);
acb_atan(c, h, prec);
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
_acb_vec_zero(g + 1, n - 1);
}
else
{
acb_ptr t, u;
slong ulen;
t = _acb_vec_init(n);
u = _acb_vec_init(n);
/* atan(h(x)) = integral(h'(x)/(1+h(x)^2)) */
ulen = FLINT_MIN(n, 2 * hlen - 1);
_acb_poly_mullow(u, h, hlen, h, hlen, ulen, prec);
acb_add_ui(u, u, 1, prec);
_acb_poly_derivative(t, h, hlen, prec);
_acb_poly_div_series(g, t, hlen - 1, u, ulen, n, prec);
_acb_poly_integral(g, g, n, prec);
_acb_vec_clear(t, n);
_acb_vec_clear(u, n);
}
acb_swap(g, c);
acb_clear(c);
}
void
_acb_dirichlet_theta_arb_series(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, const arb_t xt, slong len, slong prec)
{
acb_ptr a;
a = _acb_vec_init(len);
acb_dirichlet_chi_vec(a, G, chi, len, prec);
if (dirichlet_parity_char(G, chi))
{
slong k;
for (k = 2; k < len; k++)
acb_mul_si(a + k, a + k, k, prec);
}
acb_dirichlet_qseries_arb(res, a, xt, len, prec);
_acb_vec_clear(a, len);
}
void
sec_init(sec_t * c, slong m, acb_srcptr x, slong d)
{
slong k;
c->m = m;
c->d = d;
c->delta = n_gcd(m,d);
c->g = ((m-1)*(d-1) - c->delta + 1)/ 2;
c->roots = _acb_vec_init(d);
for (k = 0; k < d; k++)
acb_set(c->roots + k, x + k);
}
int
elliptic(acb_ptr out, const acb_t inp, void * params, long order, long prec)
{
acb_ptr t;
t = _acb_vec_init(order);
acb_set(t, inp);
if (order > 1)
acb_one(t + 1);
_acb_poly_sin_series(t, t, FLINT_MIN(2, order), order, prec);
_acb_poly_mullow(out, t, order, t, order, order, prec);
_acb_vec_scalar_mul_2exp_si(t, out, order, -1);
acb_sub_ui(t, t, 1, prec);
_acb_vec_neg(t, t, order);
_acb_poly_rsqrt_series(out, t, order, order, prec);
_acb_vec_clear(t, order);
return 0;
}
void
acb_hypgeom_jacobi_p_ui_direct(acb_t res, ulong n,
const acb_t a, const acb_t b, const acb_t z, slong prec)
{
acb_ptr terms;
acb_t t, u, v;
slong k;
terms = _acb_vec_init(n + 1);
acb_init(t);
acb_init(u);
acb_init(v);
acb_one(terms);
acb_add_ui(u, z, 1, prec);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, a, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(terms + k, terms + k - 1, t, prec);
}
acb_sub_ui(u, z, 1, prec);
acb_one(v);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, b, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(v, v, t, prec);
acb_mul(terms + n - k, terms + n - k, v, prec);
}
acb_set(res, terms);
for (k = 1; k <= n; k++)
acb_add(res, res, terms + k, prec);
_acb_vec_clear(terms, n + 1);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
_acb_poly_interpolate_fast(acb_ptr poly,
acb_srcptr xs, acb_srcptr ys, slong len, slong prec)
{
acb_ptr * tree;
acb_ptr w;
tree = _acb_poly_tree_alloc(len);
_acb_poly_tree_build(tree, xs, len, prec);
w = _acb_vec_init(len);
_acb_poly_interpolation_weights(w, tree, len, prec);
_acb_poly_interpolate_fast_precomp(poly, ys, tree, w, len, prec);
_acb_vec_clear(w, len);
_acb_poly_tree_free(tree, len);
}
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
_acb_poly_product_roots(acb_ptr poly, acb_srcptr xs, slong n, slong prec)
{
if (n == 0)
{
acb_one(poly);
}
else if (n == 1)
{
acb_neg(poly, xs);
acb_one(poly + 1);
}
else if (n == 2)
{
acb_mul(poly, xs + 0, xs + 1, prec);
acb_add(poly + 1, xs + 0, xs + 1, prec);
acb_neg(poly + 1, poly + 1);
acb_one(poly + 2);
}
else if (n == 3)
{
acb_mul(poly + 1, xs, xs + 1, prec);
acb_mul(poly, poly + 1, xs + 2, prec);
acb_neg(poly, poly);
acb_add(poly + 2, xs, xs + 1, prec);
acb_addmul(poly + 1, poly + 2, xs + 2, prec);
acb_add(poly + 2, poly + 2, xs + 2, prec);
acb_neg(poly + 2, poly + 2);
acb_one(poly + 3);
}
else
{
const slong m = (n + 1) / 2;
acb_ptr tmp;
tmp = _acb_vec_init(n + 2);
_acb_poly_product_roots(tmp, xs, m, prec);
_acb_poly_product_roots(tmp + m + 1, xs + m, n - m, prec);
_acb_poly_mul_monic(poly, tmp, m + 1, tmp + m + 1, n - m + 1, prec);
_acb_vec_clear(tmp, n + 2);
}
}
void
acb_mat_init(acb_mat_t mat, slong r, slong c)
{
if (r != 0 && c != 0)
{
slong i;
mat->entries = _acb_vec_init(r * c);
mat->rows = (acb_ptr *) flint_malloc(r * sizeof(acb_ptr));
for (i = 0; i < r; i++)
mat->rows[i] = mat->entries + i * c;
}
else
mat->entries = NULL;
mat->r = r;
mat->c = c;
}
void
acb_dirichlet_vec_mellin_arb(acb_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, const arb_t t, slong n, slong prec)
{
slong k;
arb_t tk, xt, stk, st;
acb_ptr a;
mag_t e;
a = _acb_vec_init(len);
acb_dirichlet_chi_vec(a, G, chi, len, prec);
if (dirichlet_parity_char(G, chi))
{
for (k = 2; k < len; k++)
acb_mul_si(a + k, a + k, k, prec);
}
arb_init(tk);
arb_init(xt);
arb_init(st);
arb_init(stk);
mag_init(e);
arb_sqrt(st, t, prec);
arb_one(tk);
arb_one(stk);
for (k = 0; k < n; k++)
{
_acb_dirichlet_theta_argument_at_arb(xt, G->q, tk, prec);
mag_tail_kexpk2_arb(e, xt, len);
arb_neg(xt, xt);
arb_exp(xt, xt, prec);
/* TODO: reduce len */
acb_dirichlet_qseries_arb(res + k, a, xt, len, prec);
acb_add_error_mag(res + k, e);
acb_mul_arb(res + k, res + k, stk, prec);
arb_mul(tk, tk, t, prec);
arb_mul(stk, stk, st, prec);
}
mag_clear(e);
arb_clear(xt);
arb_clear(tk);
arb_clear(stk);
arb_clear(st);
_acb_vec_clear(a, len);
}
int
acb_mat_eig_multiple(acb_ptr E, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec)
{
slong n;
acb_ptr F;
int success;
n = arb_mat_nrows(A);
F = _acb_vec_init(n);
success = acb_mat_eig_simple_vdhoeven_mourrain(F, NULL, NULL, A, E_approx, R_approx, prec);
if (!success)
success = acb_mat_eig_multiple_rump(F, A, E_approx, R_approx, prec);
_acb_vec_set(E, F, n);
_acb_vec_clear(F, n);
return success;
}
void
_acb_poly_compose_series_horner(acb_ptr res, acb_srcptr poly1, slong len1,
acb_srcptr poly2, slong len2, slong n, slong prec)
{
if (n == 1)
{
acb_set(res, poly1);
}
else
{
slong i = len1 - 1;
slong lenr;
acb_ptr t = _acb_vec_init(n);
lenr = len2;
_acb_vec_scalar_mul(res, poly2, len2, poly1 + i, prec);
i--;
acb_add(res, res, poly1 + i, prec);
while (i > 0)
{
i--;
if (lenr + len2 - 1 < n)
{
_acb_poly_mul(t, res, lenr, poly2, len2, prec);
lenr = lenr + len2 - 1;
}
else
{
_acb_poly_mullow(t, res, lenr, poly2, len2, n, prec);
lenr = n;
}
_acb_poly_add(res, t, lenr, poly1 + i, 1, prec);
}
_acb_vec_zero(res + lenr, n - lenr);
_acb_vec_clear(t, n);
}
}
void
_acb_poly_sqrt_series(acb_ptr g,
acb_srcptr h, slong hlen, slong len, slong prec)
{
hlen = FLINT_MIN(hlen, len);
while (hlen > 0 && acb_is_zero(h + hlen - 1))
hlen--;
if (hlen <= 1)
{
acb_sqrt(g, h, prec);
_acb_vec_zero(g + 1, len - 1);
}
else if (len == 2)
{
acb_sqrt(g, h, prec);
acb_div(g + 1, h + 1, h, prec);
acb_mul(g + 1, g + 1, g, prec);
acb_mul_2exp_si(g + 1, g + 1, -1);
}
else if (_acb_vec_is_zero(h + 1, hlen - 2))
{
acb_t t;
acb_init(t);
arf_set_si_2exp_si(arb_midref(acb_realref(t)), 1, -1);
_acb_poly_binomial_pow_acb_series(g, h, hlen, t, len, prec);
acb_clear(t);
}
else
{
acb_ptr t;
t = _acb_vec_init(len);
_acb_poly_rsqrt_series(t, h, hlen, len, prec);
_acb_poly_mullow(g, t, len, h, hlen, len, prec);
_acb_vec_clear(t, len);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("eisenstein....");
fflush(stdout);
flint_randinit(state);
/* Test functional equation */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t tau1, tau2, t;
acb_ptr r1, r2;
slong e0, prec0, prec1, prec2, len1, len2, i;
psl2z_t g;
psl2z_init(g);
acb_init(tau1);
acb_init(tau2);
acb_init(t);
e0 = 1 + n_randint(state, 200);
prec0 = 2 + n_randint(state, 2000);
prec1 = 2 + n_randint(state, 2000);
prec2 = 2 + n_randint(state, 2000);
len1 = n_randint(state, 20);
len2 = n_randint(state, 20);
r1 = _acb_vec_init(len1);
r2 = _acb_vec_init(len2);
acb_randtest(tau1, state, prec0, e0);
acb_randtest(tau2, state, prec0, e0);
psl2z_randtest(g, state, 1 + n_randint(state, 200));
acb_modular_transform(tau2, g, tau1, prec0);
acb_modular_eisenstein(r1, tau1, len1, prec1);
acb_modular_eisenstein(r2, tau2, len2, prec2);
for (i = 0; i < FLINT_MIN(len1, len2); i++)
{
acb_mul_fmpz(t, tau1, &g->c, prec1);
acb_add_fmpz(t, t, &g->d, prec1);
acb_pow_ui(t, t, 2 * i + 4, prec1);
acb_mul(t, t, r1 + i, prec1);
if (!acb_overlaps(t, r2 + i))
{
flint_printf("FAIL (overlap)\n");
flint_printf("tau1 = "); acb_printd(tau1, 15); flint_printf("\n\n");
flint_printf("tau2 = "); acb_printd(tau2, 15); flint_printf("\n\n");
flint_printf("g = "); psl2z_print(g); flint_printf("\n\n");
flint_printf("r1 = "); acb_printd(r1 + i, 15); flint_printf("\n\n");
flint_printf("r2 = "); acb_printd(r2 + i, 15); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 15); flint_printf("\n\n");
flint_abort();
}
}
acb_clear(tau1);
acb_clear(tau2);
acb_clear(t);
_acb_vec_clear(r1, len1);
_acb_vec_clear(r2, len2);
psl2z_clear(g);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rising2_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_t a, u, v, u2, v2;
fmpz *f;
acb_ptr g;
ulong n;
slong i, prec;
acb_init(a);
acb_init(u);
acb_init(v);
acb_init(u2);
acb_init(v2);
acb_randtest(a, state, 1 + n_randint(state, 4000), 10);
acb_randtest(u, state, 1 + n_randint(state, 4000), 10);
acb_randtest(v, state, 1 + n_randint(state, 4000), 10);
n = n_randint(state, 120);
f = _fmpz_vec_init(n + 1);
g = _acb_vec_init(n + 1);
prec = 2 + n_randint(state, 4000);
acb_rising2_ui(u, v, a, n, prec);
arith_stirling_number_1u_vec(f, n, n + 1);
for (i = 0; i <= n; i++)
acb_set_fmpz(g + i, f + i);
_acb_poly_evaluate(u2, g, n + 1, a, prec);
_acb_poly_derivative(g, g, n + 1, prec);
_acb_poly_evaluate(v2, g, n, a, prec);
if (!acb_overlaps(u, u2) || !acb_overlaps(v, v2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu\n", n);
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n\n");
flint_printf("u = "); acb_printd(u, 15); flint_printf("\n\n");
flint_printf("u2 = "); acb_printd(u2, 15); flint_printf("\n\n");
flint_printf("v = "); acb_printd(v, 15); flint_printf("\n\n");
flint_printf("v2 = "); acb_printd(v2, 15); flint_printf("\n\n");
abort();
}
acb_set(u2, a);
acb_rising2_ui(u2, v, u2, n, prec);
if (!acb_equal(u2, u))
{
flint_printf("FAIL: aliasing 1\n\n");
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n\n");
flint_printf("u = "); acb_printd(u, 15); flint_printf("\n\n");
flint_printf("u2 = "); acb_printd(u2, 15); flint_printf("\n\n");
flint_printf("n = %wu\n", n);
abort();
}
acb_set(v2, a);
acb_rising2_ui(u, v2, v2, n, prec);
if (!acb_equal(v2, v))
{
flint_printf("FAIL: aliasing 2\n\n");
flint_printf("a = "); acb_printd(a, 15); flint_printf("\n\n");
flint_printf("v = "); acb_printd(v, 15); flint_printf("\n\n");
flint_printf("v2 = "); acb_printd(v2, 15); flint_printf("\n\n");
flint_printf("n = %wu\n", n);
abort();
}
acb_clear(a);
acb_clear(u);
acb_clear(v);
acb_clear(u2);
acb_clear(v2);
_fmpz_vec_clear(f, n + 1);
_acb_vec_clear(g, n + 1);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pfq_sum_rs....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_ptr a, b;
acb_t z, s1, s2, t1, t2;
slong i, p, q, n, prec1, prec2;
p = n_randint(state, 5);
q = n_randint(state, 5);
n = n_randint(state, 300);
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
acb_init(z);
acb_init(s1);
acb_init(s2);
acb_init(t1);
acb_init(t2);
acb_randtest_special(z, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(s1, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(t1, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(s2, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(t2, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
a = _acb_vec_init(p);
b = _acb_vec_init(q);
for (i = 0; i < p; i++)
acb_randtest(a + i, state, 1 + n_randint(state, 100), 1 + n_randint(state, 10));
for (i = 0; i < q; i++)
acb_randtest(b + i, state, 1 + n_randint(state, 100), 1 + n_randint(state, 10));
acb_hypgeom_pfq_sum_forward(s1, t1, a, p, b, q, z, n, prec1);
acb_hypgeom_pfq_sum_rs(s2, t2, a, p, b, q, z, n, prec2);
if (!acb_overlaps(s1, s2) || !acb_overlaps(t1, t2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("z = "); acb_print(a); flint_printf("\n\n");
flint_printf("s1 = "); acb_print(s1); flint_printf("\n\n");
flint_printf("s2 = "); acb_print(s2); flint_printf("\n\n");
flint_printf("t1 = "); acb_print(t1); flint_printf("\n\n");
flint_printf("t2 = "); acb_print(t2); flint_printf("\n\n");
flint_abort();
}
_acb_vec_clear(a, p);
_acb_vec_clear(b, q);
acb_clear(z);
acb_clear(s1);
acb_clear(s2);
acb_clear(t1);
acb_clear(t2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
