void
_acb_poly_div_root(acb_ptr Q, acb_t R, acb_srcptr A,
slong len, const acb_t c, slong prec)
{
acb_t r, t;
slong i;
if (len < 2)
{
acb_zero(R);
return;
}
acb_init(r);
acb_init(t);
acb_set(t, A + len - 2);
acb_set(Q + len - 2, A + len - 1);
acb_set(r, Q + len - 2);
/* TODO: avoid the extra assignments (but still support aliasing) */
for (i = len - 2; i > 0; i--)
{
acb_mul(r, r, c, prec);
acb_add(r, r, t, prec);
acb_set(t, A + i - 1);
acb_set(Q + i - 1, r);
}
acb_mul(r, r, c, prec);
acb_add(R, r, t, prec);
acb_clear(r);
acb_clear(t);
}
/* todo: remove radii */
void
acb_lambertw_halley_step(acb_t res, acb_t ew, const acb_t z, const acb_t w, slong prec)
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
acb_exp(ew, w, prec);
acb_add_ui(u, w, 2, prec);
acb_add_ui(v, w, 1, prec);
acb_mul_2exp_si(v, v, 1);
acb_div(v, u, v, prec);
acb_mul(t, ew, w, prec);
acb_sub(u, t, z, prec);
acb_mul(v, v, u, prec);
acb_neg(v, v);
acb_add(v, v, t, prec);
acb_add(v, v, ew, prec);
acb_div(t, u, v, prec);
acb_sub(t, w, t, prec);
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_lambertw_initial_asymp(acb_t w, const acb_t z, const fmpz_t k, slong prec)
{
acb_t L1, L2, t;
acb_init(L1);
acb_init(L2);
acb_init(t);
acb_const_pi(L2, prec);
acb_mul_2exp_si(L2, L2, 1);
acb_mul_fmpz(L2, L2, k, prec);
acb_mul_onei(L2, L2);
acb_log(L1, z, prec);
acb_add(L1, L1, L2, prec);
acb_log(L2, L1, prec);
/* L1 - L2 + L2/L1 + L2(L2-2)/(2 L1^2) */
acb_inv(t, L1, prec);
acb_mul_2exp_si(w, L2, 1);
acb_submul(w, L2, L2, prec);
acb_neg(w, w);
acb_mul(w, w, t, prec);
acb_mul_2exp_si(w, w, -1);
acb_add(w, w, L2, prec);
acb_mul(w, w, t, prec);
acb_sub(w, w, L2, prec);
acb_add(w, w, L1, prec);
acb_clear(L1);
acb_clear(L2);
acb_clear(t);
}
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_hypgeom_bessel_j_asymp_prefactors(acb_t Ap, acb_t Am, acb_t C,
const acb_t nu, const acb_t z, long prec)
{
if (arb_is_positive(acb_realref(z)))
{
acb_t t, u;
acb_init(t);
acb_init(u);
/* -(2nu+1)/4 * pi + z */
acb_mul_2exp_si(t, nu, 1);
acb_add_ui(t, t, 1, prec);
acb_mul_2exp_si(t, t, -2);
acb_neg(t, t);
acb_const_pi(u, prec);
acb_mul(t, t, u, prec);
acb_add(t, t, z, prec);
acb_mul_onei(t, t);
acb_exp_invexp(Ap, Am, t, prec);
/* (2 pi z)^(-1/2) */
acb_const_pi(C, prec);
acb_mul_2exp_si(C, C, 1);
acb_mul(C, C, z, prec);
acb_rsqrt(C, C, prec);
acb_clear(t);
acb_clear(u);
return;
}
acb_hypgeom_bessel_j_asymp_prefactors_fallback(Ap, Am, C, nu, z, prec);
}
void
acb_modular_elliptic_e(acb_t res, const acb_t m, long prec)
{
if (acb_is_zero(m))
{
acb_const_pi(res, prec);
acb_mul_2exp_si(res, res, -1);
}
else if (acb_is_one(m))
{
acb_one(res);
}
else
{
acb_struct t[2];
acb_init(t + 0);
acb_init(t + 1);
acb_modular_elliptic_k_cpx(t, m, 2, prec);
acb_mul(t + 1, t + 1, m, prec);
acb_mul_2exp_si(t + 1, t + 1, 1);
acb_add(t, t, t + 1, prec);
acb_sub_ui(t + 1, m, 1, prec);
acb_mul(res, t, t + 1, prec);
acb_neg(res, res);
acb_clear(t + 0);
acb_clear(t + 1);
}
}
/* Differential equation for F(a,b,c,y+z):
(y+z)(y-1+z) F''(z) + ((y+z)(a+b+1) - c) F'(z) + a b F(z) = 0
Coefficients in the Taylor series are bounded by
A * binomial(N+k, k) * nu^k
using the Cauchy-Kovalevskaya majorant method.
See J. van der Hoeven, "Fast evaluation of holonomic functions near
and in regular singularities"
*/
static void
bound(mag_t A, mag_t nu, mag_t N,
const acb_t a, const acb_t b, const acb_t c, const acb_t y,
const acb_t f0, const acb_t f1)
{
mag_t M0, M1, t, u;
acb_t d;
acb_init(d);
mag_init(M0);
mag_init(M1);
mag_init(t);
mag_init(u);
/* nu = max(1/|y-1|, 1/|y|) = 1/min(|y-1|, |y|) */
acb_get_mag_lower(t, y);
acb_sub_ui(d, y, 1, MAG_BITS);
acb_get_mag_lower(u, d);
mag_min(t, t, u);
mag_one(u);
mag_div(nu, u, t);
/* M0 = 2 nu |ab| */
acb_get_mag(t, a);
acb_get_mag(u, b);
mag_mul(M0, t, u);
mag_mul(M0, M0, nu);
mag_mul_2exp_si(M0, M0, 1);
/* M1 = 2 nu |(a+b+1)y-c| + 2|a+b+1| */
acb_add(d, a, b, MAG_BITS);
acb_add_ui(d, d, 1, MAG_BITS);
acb_get_mag(t, d);
acb_mul(d, d, y, MAG_BITS);
acb_sub(d, d, c, MAG_BITS);
acb_get_mag(u, d);
mag_mul(u, u, nu);
mag_add(M1, t, u);
mag_mul_2exp_si(M1, M1, 1);
/* N = max(sqrt(2 M0), 2 M1) / nu */
mag_mul_2exp_si(M0, M0, 1);
mag_sqrt(M0, M0);
mag_mul_2exp_si(M1, M1, 1);
mag_max(N, M0, M1);
mag_div(N, N, nu);
/* A = max(|f0|, |f1| / (nu (N+1)) */
acb_get_mag(t, f0);
acb_get_mag(u, f1);
mag_div(u, u, nu);
mag_div(u, u, N); /* upper bound for dividing by N+1 */
mag_max(A, t, u);
acb_clear(d);
mag_clear(M0);
mag_clear(M1);
mag_clear(t);
mag_clear(u);
}
int
f_monster(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_exp(t, z, prec);
acb_real_floor(res, t, order != 0, prec);
if (acb_is_finite(res))
{
acb_sub(res, t, res, prec);
acb_add(t, t, z, prec);
acb_sin(t, t, prec);
acb_mul(res, res, t, prec);
}
acb_clear(t);
return 0;
}
/* f(z) = erf(z/sqrt(0.0002)*0.5 +1.5)*exp(-z), example provided by Silviu-Ioan Filip */
int
f_erf_bent(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_set_ui(t, 1250);
acb_sqrt(t, t, prec);
acb_mul(t, t, z, prec);
acb_set_d(res, 1.5);
acb_add(res, res, t, prec);
acb_hypgeom_erf(res, res, prec);
acb_neg(t, z);
acb_exp(t, t, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return 0;
}
/* f(z) = sin((1/1000 + (1-z)^2)^(-3/2)), example from Mioara Joldes' thesis
(suggested by Nicolas Brisebarre) */
int
f_sin_near_essing(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t, u;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_init(u);
acb_sub_ui(t, z, 1, prec);
acb_neg(t, t);
acb_mul(t, t, t, prec);
acb_one(u);
acb_div_ui(u, u, 1000, prec);
acb_add(t, t, u, prec);
acb_set_d(u, -1.5);
acb_pow_analytic(t, t, u, order != 0, prec);
acb_sin(res, t, prec);
acb_clear(t);
acb_clear(u);
return 0;
}
void fft(acb_t *x) {
long *base=(long *)x-2,i,j,k,l;
long n=base[0],prec=base[1],halfn=n>>1;
acb_t *p,*w=x+n;
static acb_t ctemp;
static int init;
if (!init) {
acb_init(ctemp);
init = 1;
}
/* swap each element with one with bit-reversed index */
for (i=0;i<halfn;++i) {
/* j = bit reversal of i */
for (k=1,j=0;k<n;k<<=1) {
j <<= 1;
if (i & k) j |= 1;
}
if (i < j)
acb_swap(x[i],x[j]);
else if (i > j)
acb_swap(x[n-1-i],x[n-1-j]);
++i, j |= halfn;
acb_swap(x[i],x[j]);
}
for (k=1,l=halfn;k<n;k<<=1,l>>=1)
for (p=x;p<w;p+=k)
for (j=0;j<halfn;j+=l,p++) {
acb_mul(ctemp,p[k],w[j],prec);
acb_sub(p[k],p[0],ctemp,prec);
acb_add(p[0],p[0],ctemp,prec);
}
}
void
acb_hypgeom_m_asymp(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
acb_t t, u, v, c;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(c);
acb_sub(c, b, a, prec);
acb_neg(v, z);
acb_hypgeom_u_asymp(t, a, b, z, -1, prec);
acb_hypgeom_u_asymp(u, c, b, v, -1, prec);
/* gamma(b-a) */
acb_rgamma(v, c, prec);
acb_mul(t, t, v, prec);
/* z^(a-b) */
acb_neg(c, c);
acb_pow(v, z, c, prec);
acb_mul(u, u, v, prec);
/* gamma(a) */
acb_rgamma(v, a, prec);
acb_mul(u, u, v, prec);
/* exp(z) */
acb_exp(v, z, prec);
acb_mul(u, u, v, prec);
/* (-z)^(-a) */
acb_neg(c, a);
acb_neg(v, z);
acb_pow(v, v, c, prec);
acb_mul(t, t, v, prec);
acb_add(t, t, u, prec);
if (!regularized)
{
acb_gamma(v, b, prec);
acb_mul(t, t, v, prec);
}
if (acb_is_real(a) && acb_is_real(b) && acb_is_real(z))
{
arb_zero(acb_imagref(t));
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(c);
}
int main()
{
long iter;
flint_rand_t state;
printf("exp....");
fflush(stdout);
flint_randinit(state);
/* check exp(a+b) = exp(a)*exp(b) */
for (iter = 0; iter < 10000; iter++)
{
acb_t a, b, c, d, e;
long prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_randtest(a, state, 1 + n_randint(state, 200), 3);
acb_randtest(b, state, 1 + n_randint(state, 200), 3);
acb_randtest(c, state, 1 + n_randint(state, 200), 3);
prec = 2 + n_randint(state, 200);
acb_add(c, a, b, prec);
acb_exp(c, c, prec);
acb_exp(d, a, prec);
acb_exp(e, b, prec);
acb_mul(d, d, e, prec);
if (!acb_overlaps(c, d))
{
printf("FAIL: overlap\n\n");
printf("a = "); acb_print(a); printf("\n\n");
printf("b = "); acb_print(b); printf("\n\n");
printf("c = "); acb_print(c); printf("\n\n");
printf("d = "); acb_print(d); printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
static void
bsplit(acb_t p, acb_t q, const acb_t x, ulong a, ulong b, slong prec)
{
if (b - a < 8)
{
ulong k;
acb_t t;
acb_one(p);
acb_add_ui(q, x, a, prec);
acb_init(t);
for (k = a + 1; k < b; k++)
{
acb_add_ui(t, x, k, prec);
acb_mul(p, p, t, prec);
acb_add(p, p, q, prec);
acb_mul(q, q, t, prec);
}
acb_clear(t);
}
else
{
acb_t r, s;
ulong m;
acb_init(r);
acb_init(s);
m = a + (b - a) / 2;
bsplit(p, q, x, a, m, prec);
bsplit(r, s, x, m, b, prec);
acb_mul(p, p, s, prec);
acb_mul(r, r, q, prec);
acb_add(p, p, r, prec);
acb_mul(q, q, s, prec);
acb_clear(r);
acb_clear(s);
}
}
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_hypgeom_jacobi_p(acb_t res, const acb_t n, const acb_t a, const acb_t b,
const acb_t z, slong prec)
{
acb_t t, u, v, w;
if (use_recurrence(n, a, b, prec))
{
acb_hypgeom_jacobi_p_ui_direct(res,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), a, b, z, prec);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(w);
acb_neg(t, n);
acb_add_ui(v, a, 1, prec);
acb_add(u, n, v, prec);
acb_add(u, u, b, prec);
acb_sub_ui(w, z, 1, prec);
acb_mul_2exp_si(w, w, -1);
acb_neg(w, w);
acb_hypgeom_2f1(w, t, u, v, w, 0, prec);
acb_rising(t, v, n, prec);
acb_mul(w, w, t, prec);
acb_add_ui(t, n, 1, prec);
acb_rgamma(t, t, prec);
acb_mul(w, w, t, prec);
acb_set(res, w);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(w);
}
/* f(z) = sin(z + exp(z)) -- Rump's oscillatory example */
int
f_rump(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_exp(res, z, prec);
acb_add(res, res, z, prec);
acb_sin(res, res, prec);
return 0;
}
void acb_hypgeom_beta_lower(acb_t res,
const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
acb_t t, u;
if (acb_is_zero(z) && arb_is_positive(acb_realref(a)))
{
acb_zero(res);
return;
}
if (acb_is_one(z) && arb_is_positive(acb_realref(b)))
{
if (regularized)
acb_one(res);
else
acb_beta(res, a, b, prec);
return;
}
acb_init(t);
acb_init(u);
acb_sub_ui(t, b, 1, prec);
acb_neg(t, t);
acb_add_ui(u, a, 1, prec);
if (regularized)
{
acb_hypgeom_2f1(t, a, t, u, z, 1, prec);
acb_add(u, a, b, prec);
acb_gamma(u, u, prec);
acb_mul(t, t, u, prec);
acb_rgamma(u, b, prec);
acb_mul(t, t, u, prec);
}
else
{
acb_hypgeom_2f1(t, a, t, u, z, 0, prec);
acb_div(t, t, a, prec);
}
acb_pow(u, z, a, prec);
acb_mul(t, t, u, prec);
acb_set(res, t);
acb_clear(t);
acb_clear(u);
}
/* f(z) = sech(10(x-0.2))^2 + sech(100(x-0.4))^4 + sech(1000(x-0.6))^6 */
int
f_spike(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t a, b, c;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(a);
acb_init(b);
acb_init(c);
acb_mul_ui(a, z, 10, prec);
acb_sub_ui(a, a, 2, prec);
acb_sech(a, a, prec);
acb_pow_ui(a, a, 2, prec);
acb_mul_ui(b, z, 100, prec);
acb_sub_ui(b, b, 40, prec);
acb_sech(b, b, prec);
acb_pow_ui(b, b, 4, prec);
acb_mul_ui(c, z, 1000, prec);
acb_sub_ui(c, c, 600, prec);
acb_sech(c, c, prec);
acb_pow_ui(c, c, 6, prec);
acb_add(res, a, b, prec);
acb_add(res, res, c, prec);
acb_clear(a);
acb_clear(b);
acb_clear(c);
return 0;
}
void
_acb_poly_add(acb_ptr res, acb_srcptr poly1, long len1,
acb_srcptr poly2, long len2, long prec)
{
long i, min = FLINT_MIN(len1, len2);
for (i = 0; i < min; i++)
acb_add(res + i, poly1 + i, poly2 + i, prec);
for (i = min; i < len1; i++)
acb_set_round(res + i, poly1 + i, prec);
for (i = min; i < len2; i++)
acb_set_round(res + i, poly2 + i, prec);
}
/* res = src * (c + x) */
void _acb_poly_mullow_cpx(acb_ptr res, acb_srcptr src, slong len, const acb_t c, slong trunc, slong prec)
{
slong i;
if (len < trunc)
acb_set(res + len, src + len - 1);
for (i = len - 1; i > 0; i--)
{
acb_mul(res + i, src + i, c, prec);
acb_add(res + i, res + i, src + i - 1, prec);
}
acb_mul(res, src, c, prec);
}
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);
}
/* f(z) = sin(z) + exp(-200-z^2) */
int
f_sin_plus_small(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_mul(t, z, z, prec);
acb_add_ui(t, t, 200, prec);
acb_neg(t, t);
acb_exp(t, t, prec);
acb_sin(res, z, prec);
acb_add(res, res, t, prec);
acb_clear(t);
return 0;
}
void
acb_digamma(acb_t y, const acb_t x, long prec)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 1, wp);
acb_init(t);
acb_init(u);
acb_init(v);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_cot_pi(v, x, wp);
arb_const_pi(acb_realref(u), wp);
acb_mul_arb(v, v, acb_realref(u), wp);
acb_rising2_ui(y, u, t, r, wp);
acb_div(u, u, y, wp);
acb_add(v, v, u, wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_sub(y, u, v, wp);
}
else
{
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_rising2_ui(y, t, x, r, wp);
acb_div(t, t, y, wp);
acb_sub(y, u, t, prec);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
/* todo: move this to the acb module? */
static void
acb_beta(acb_t res, const acb_t a, const acb_t b, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_gamma(t, a, prec);
acb_gamma(u, b, prec);
acb_add(res, a, b, prec);
acb_rgamma(res, res, prec);
acb_mul(res, res, t, prec);
acb_mul(res, res, u, prec);
acb_clear(t);
acb_clear(u);
}
int
f_lambertw(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
prec = FLINT_MIN(prec, acb_rel_accuracy_bits(z) + 10);
if (order != 0)
{
/* check for branch cut */
arb_const_e(acb_realref(t), prec);
acb_inv(t, t, prec);
acb_add(t, t, z, prec);
if (arb_contains_zero(acb_imagref(t)) &&
arb_contains_nonpositive(acb_realref(t)))
{
acb_indeterminate(t);
}
}
if (acb_is_finite(t))
{
fmpz_t k;
fmpz_init(k);
acb_lambertw(res, z, k, 0, prec);
fmpz_clear(k);
}
else
{
acb_indeterminate(res);
}
acb_clear(t);
return 0;
}
/* (+/- iz)^(-1/2-v) * z^v * exp(+/- iz) */
void
acb_hypgeom_bessel_j_asymp_prefactors_fallback(acb_t Ap, acb_t Am, acb_t C,
const acb_t nu, const acb_t z, long prec)
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
/* v = -1/2-nu */
acb_one(v);
acb_mul_2exp_si(v, v, -1);
acb_add(v, v, nu, prec);
acb_neg(v, v);
acb_mul_onei(t, z); /* t = iz */
acb_neg(u, t); /* u = -iz */
/* Ap, Am = (+/- iz)^(-1/2-nu) */
acb_pow(Ap, t, v, prec);
acb_pow(Am, u, v, prec);
/* Ap, Am *= exp(+/- iz) */
acb_exp_invexp(u, v, t, prec);
acb_mul(Ap, Ap, u, prec);
acb_mul(Am, Am, v, prec);
/* z^nu */
acb_pow(t, z, nu, prec);
acb_mul(Ap, Ap, t, prec);
acb_mul(Am, Am, t, prec);
/* (2 pi)^(-1/2) */
acb_const_pi(C, prec);
acb_mul_2exp_si(C, C, 1);
acb_rsqrt(C, C, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_rising(acb_t y, const acb_t x, const acb_t n, long prec)
{
if (acb_is_int(n) && arf_sgn(arb_midref(acb_realref(n))) >= 0 &&
arf_cmpabs_ui(arb_midref(acb_realref(n)), FLINT_MAX(prec, 100)) < 0)
{
acb_rising_ui_rec(y, x,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), prec);
}
else
{
acb_t t;
acb_init(t);
acb_add(t, x, n, prec);
acb_gamma(t, t, prec);
acb_rgamma(y, x, prec);
acb_mul(y, y, t, prec);
acb_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
_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);
}
}
