acb_series – power series over complex numbers

class flint.acb_series(val=None, prec=None)

Arb series.

>>> from flint import acb_series, ctx
>>> ctx.cap = 3
>>> x = acb_series([0, 1])
>>> x
1.00000000000000*x + O(x^3)
>>> 1 / (1 + x)
1.00000000000000 + (-1.00000000000000)*x + 1.00000000000000*x^2 + O(x^3)
>>> x.cos()
1.00000000000000 + (-0.500000000000000)*x^2 + O(x^3)

agm(s, t=None)

airy(s)

airy_ai(s)

airy_ai_prime(s)

airy_bi(s)

airy_bi_prime(s)

atan(s)

classmethod beta_lower(cls, a, b, z, int regularized=0)

chi(s)

ci(s)

coeffs(self)

cos(s)

cos_pi(s)

cot_pi(s)

coulomb(self, l, eta)

coulomb_f(self, l, eta)

coulomb_g(self, l, eta)

derivative(s)

dirichlet_l(s, chi, bool deflate=0)

ei(s)

elliptic_k(s)

elliptic_p(s, tau)

erf(s)

erfc(s)

erfi(s)

exp(s)

fresnel(s, bool normalized=True)

fresnel_c(s, bool normalized=True)

fresnel_s(s, bool normalized=True)

gamma(s)

classmethod gamma_lower(cls, s, z, int regularized=0)

classmethod gamma_upper(cls, s, z, int regularized=0)

classmethod hypgeom(cls, a, b, z, long n=-1, bool regularized=False)

Computes the generalized hypergeometric function \({}_pF_q(a;b;z)\) given lists of power series \(a\) and \(b\) and a power series \(z\).

The optional parameter n, if nonnegative, controls the number of terms to add in the hypergeometric series. This is just a tuning parameter: a rigorous error bound is computed regardless of n.

integral(s)

inv(s)

lambertw(s, branch=0)

length(self) → long

lgamma(s)

li(s, bool offset=False)

log(s)

modular_theta(self, tau)

classmethod polylog(cls, s, z)

prec

The precision of the finitely approximated power series.

>>> from flint import acb_series, ctx
>>> ctx.cap = 10
>>> a = acb_series([1,2,3])
>>> a
1.00000000000000 + 2.00000000000000*x + 3.00000000000000*x^2 + O(x^10)
>>> a.prec
10
>>> b = acb_series([1,2,3], prec=5)
>>> b
1.00000000000000 + 2.00000000000000*x + 3.00000000000000*x^2 + O(x^5)
>>> b.prec
5

repr(self, **kwargs)

reversion(s)

rgamma(s)

rising(s, ulong n)

rsqrt(s)

shi(s)

si(s)

sin(s)

sin_cos(s)

sin_cos_pi(s)

sin_pi(s)

sqrt(s)

str(self, *args, **kwargs)

tan(s)

valuation(self)

zeta(s, a=1, bool deflate=0)