acb – complex numbers

class flint.acb(real=None, imag=None)

An acb represents a complex number by a rectangular enclosure consisting of arb balls for the real and imaginary parts.

>>> from flint import fmpq
>>> acb(2)
2.00000000000000
>>> acb(2+3j)
2.00000000000000 + 3.00000000000000j
>>> acb("2 +/- 0.001", fmpq(2,3))
[2.00 +/- 1.01e-3] + [0.666666666666667 +/- 4.82e-16]j
>>> acb(-1) ** 0.25
[0.707106781186547 +/- 6.14e-16] + [0.707106781186547 +/- 6.15e-16]j

abs_lower(self)

Lower bound for the absolute value of self. The output is an arb holding an exact floating-point number that has been rounded down to the current precision.

>>> print(acb(3, "-5 +/- 2").abs_lower().str(5, radius=False))
4.2426

abs_upper(self)

Upper bound for the absolute value of self. The output is an arb holding an exact floating-point number that has been rounded up to the current precision.

>>> print(acb(3, "-5 +/- 2").abs_upper().str(5, radius=False))
7.6158

acos(s)

Inverse cosine \(\operatorname{acos}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2).acos(), dps=25)
1.316957896924816708625046j

acosh(s)

Inverse hyperbolic cosine \(\operatorname{acosh}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).acosh(), dps=25)
1.983387029916535432347077 + 1.000143542473797218521038j

agm(s, t=None)

Arithmetic-geometric mean \(M(s,t)\), or \(M(s) = M(s,1)\) if no extra parameter is passed.

>>> from flint import showgood
>>> showgood(lambda: acb(2).agm(), dps=25)
1.456791031046906869186432
>>> showgood(lambda: acb(1,1).agm(), dps=25)
1.049160528732780220531827 + 0.4781557460881612293261882j
>>> showgood(lambda: (acb(-95,-65)/100).agm(acb(684,747)/1000), dps=25)
-0.3711072435676023931065922 + 0.3199561471173686568561674j

airy(s)

Computes the Airy function values \(\operatorname{Ai}(s)\), \(\operatorname{Ai}'(s)\), \(\operatorname{Bi}(s)\), \(\operatorname{Bi}'(s)\) simultaneously, returning a tuple.

>>> from flint import showgood
>>> showgood(lambda: acb(-1+1j).airy(), dps=5)
(0.82212 - 0.11997j, -0.37906 - 0.60450j, 0.21429 + 0.67392j, 0.83447 - 0.34653j)

airy_ai(s, int derivative=0)

Airy function \(\operatorname{Ai}(s)\), or \(\operatorname{Ai}'(s)\) if derivative is 1.

>>> from flint import showgood
>>> showgood(lambda: acb(-1+1j).airy_ai(), dps=25)
0.8221174265552725939610246 - 0.1199663426644243438939006j
>>> showgood(lambda: acb(-1+1j).airy_ai(derivative=1), dps=25)
-0.3790604792268334962367164 - 0.6045001308622460716372591j

airy_bi(s, int derivative=0)

Airy function \(\operatorname{Bi}(s)\), or \(\operatorname{Bi}'(s)\) if derivative is 1.

>>> from flint import showgood
>>> showgood(lambda: acb(-1+1j).airy_bi(), dps=25)
0.2142904015348735739780868 + 0.6739169237227052095951775j
>>> showgood(lambda: acb(-1+1j).airy_bi(derivative=1), dps=25)
0.8344734885227826369040951 - 0.3465260632668285285537957j

arg(self)

Complex argument (phase).

>>> from flint import showgood
>>> showgood(lambda: acb("3.3").arg(), dps=25)
0
>>> showgood(lambda: acb(-1).arg(), dps=25)
3.141592653589793238462643
>>> acb(-1, "+/- 1").arg()
[+/- 3.15]

asin(s)

Inverse sine \(\operatorname{asin}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2).asin(), dps=25)
1.570796326794896619231322 - 1.316957896924816708625046j

asinh(s)

Inverse hyperbolic sine \(\operatorname{asinh}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).asinh(), dps=25)
1.968637925793096291788665 + 0.9646585044076027920454111j

atan(s)

Computes the inverse tangent \(\operatorname{atan}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).atan(), dps=25)
1.338972522294493561124194 + 0.4023594781085250936501898j

atanh(s)

Inverse hyperbolic tangent \(\operatorname{atanh}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).atanh(), dps=25)
0.1469466662255297520474328 + 1.338972522294493561124194j

barnes_g(s)

Barnes G-function \(G(s)\).

>>> acb(8).barnes_g()
24883200.0000000
>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).barnes_g(), dps=25)
-0.1781021386408216960641890 + 0.04504542715447837909120582j

bernoulli_poly(s, ulong n)

Returns the value of the Bernoulli polynomial \(B_n(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(0.25+0.25j).bernoulli_poly(5), dps=25)
-0.05859375000000000000000000 + 0.006510416666666666666666667j

bessel_i(self, n, bool scaled=False)

Bessel function \(I_n(z)\), where the argument z is given by self and the order n is passed as an extra parameter. Optionally a scaled Bessel function can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(5).bessel_i(1), dps=25)
24.33564214245052719914305
>>> showgood(lambda: acb(5).bessel_i(1, scaled=True), dps=25)
0.1639722669445423569261229

bessel_j(self, n)

Bessel function \(J_n(z)\), where the argument z is given by self and the order n is passed as an extra parameter.

>>> from flint import showgood
>>> showgood(lambda: acb(5).bessel_j(1), dps=25)
-0.3275791375914652220377343
>>> showgood(lambda: acb(2+3j).bessel_j(1+2j), dps=25)
0.5041904509946947234759103 - 0.1765180072689450645147231j

bessel_k(self, n, bool scaled=False)

Bessel function \(K_n(z)\), where the argument z is given by self and the order n is passed as an extra parameter. Optionally a scaled Bessel function can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(5).bessel_k(1), dps=25)
0.004044613445452164208365022
>>> showgood(lambda: acb(5).bessel_k(1, scaled=True), dps=25)
0.6002738587883125829360457
>>> showgood(lambda: acb(2+3j).bessel_k(1+2j), dps=25)
-0.09884736370006798963642719 - 0.02870616366668971734065520j

bessel_y(self, n)

Bessel function \(Y_n(z)\), where the argument z is given by self and the order n is passed as an extra parameter.

>>> from flint import showgood
>>> showgood(lambda: acb(5).bessel_y(1), dps=25)
0.1478631433912268448010507

beta_lower(self, a, b, int regularized=0)

Lower incomplete beta function \(B(a,b;z)\). The argument z is given by self and the parameters a and b are passed as extra function arguments. Optionally the regularized version of this function can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).beta_lower(1, 2.5), dps=25)
0.2650137734913866999568502 - 7.111836702381954625752124j
>>> showgood(lambda: acb(2,3).beta_lower(1, 2.5, regularized=True), dps=25)
0.6625344337284667498921254 - 17.77959175595488656438031j

bits(self)

Returns maximum of arb.bits() called on real and imaginary part.

>>> acb("2047/2048").bits()
11

chebyshev_t(s, n)

Chebyshev function of the first kind \(T_n(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).chebyshev_t(3), dps=25)
-0.8518518518518518518518519

chebyshev_u(s, n)

Chebyshev function of the second kind \(U_n(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).chebyshev_u(3), dps=25)
-1.037037037037037037037037

chi(s)

Hyperbolic cosine integral \(\operatorname{Chi}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).chi(), dps=25)
1246.114486042454414726558

ci(s)

Cosine integral \(\operatorname{Ci}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).ci(), dps=25)
-0.04545643300445537263453283

complex_rad(self)

Returns an acb representing the radii of the real and imaginary parts of self together a single complex number.

>>> print(acb("1 +/- 0.3", "2 +/- 0.4").complex_rad().str(5, radius=False))
0.30000 + 0.40000j

conjugate(self, bool exact=False)

contains(self, other)

contains_integer(self)

contains_interior(self, other)

cos(s)

Cosine function \(\cos(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).cos(), dps=25)
2.032723007019665529436343 - 3.051897799151800057512116j

cos_pi(s)

Cosine function \(\cos(\pi s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).cos_pi(), dps=25)
-267.7467614837482222459319

cosh(s)

Hyperbolic cosine function \(\cosh(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).cosh(), dps=25)
-3.724545504915322565473971 + 0.5118225699873846088344638j

cot(s)

Cotangent function \(\cot(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).cot(), dps=25)
0.03279775553375259406276455 - 0.9843292264581910294718882j

cot_pi(s)

Cotangent function \(\cot(\pi s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).cot_pi(), dps=25)
-1.000006974709035616233122j

coth(s)

Hyperbolic cotangent function \(\coth(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).coth(), dps=25)
1.035746637764995396112759 + 0.01060478347033710175031690j

coulomb(self, l, eta)

Computes the Coulomb wave functions \(F_{\ell}(\eta,z)\), \(G_{\ell}(\eta,z)\), \(H^{+}_{\ell}(\eta,z)\), \(H^{-}_{\ell}(\eta,z)\) where z is given by self. All function values are computed simultaneously and a tuple is returned.

>>> from flint import showgood
>>> showgood(lambda: acb(1).coulomb(0.5, 0.25), dps=10)
(0.4283180781, 1.218454487, 1.218454487 + 0.4283180781j, 1.218454487 - 0.4283180781j)

coulomb_f(self, l, eta)

Regular Coulomb wave function \(F_{\ell}(\eta,z)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb(1+1j).coulomb_f(0.5, 0.25), dps=25)
0.3710338871231483199425544 + 0.7267604204004146050054782j

coulomb_g(self, l, eta)

Irregular Coulomb wave function \(G_{\ell}(\eta,z)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb(1+1j).coulomb_g(0.5, 0.25), dps=25)
1.293346292234270672155324 - 0.3516893313311703662702556j

csc(s)

Cosecant function \(\sec(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).csc(), dps=25)
0.09047320975320743980579048 + 0.04120098628857412646300981j

csch(s)

Hyperbolic cosecant function \(\operatorname{csch}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).csch(), dps=25)
-0.2725486614629401995124985 - 0.04030057885689152187513248j

csgn(self)

Complex sign function defined as a piecewise extension of the real sign function.

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).csgn(), dps=25)
1.000000000000000000000000
>>> showgood(lambda: acb(-1).csgn(), dps=25)
-1.000000000000000000000000

static dft(vec, bool inverse=False)

Returns the discrete Fourier transform (DFT) of a given iterable vec. The output is a list of acb entries. If inverse is True, computes the inverse transform instead.

>>> for c in acb.dft(acb.dft(range(1,12)), inverse=True):
...     print(c)
...
[1.000000000000 +/- 1.06e-13] + [+/- 8.66e-14]j
[2.000000000000 +/- 1.25e-13] + [+/- 1.17e-13]j
[3.000000000000 +/- 1.29e-13] + [+/- 1.21e-13]j
[4.000000000000 +/- 1.34e-13] + [+/- 1.22e-13]j
[5.000000000000 +/- 1.40e-13] + [+/- 1.24e-13]j
[6.000000000000 +/- 1.50e-13] + [+/- 1.26e-13]j
[7.000000000000 +/- 1.43e-13] + [+/- 1.26e-13]j
[8.000000000000 +/- 1.47e-13] + [+/- 1.23e-13]j
[9.000000000000 +/- 1.47e-13] + [+/- 1.22e-13]j
[10.00000000000 +/- 1.50e-13] + [+/- 1.20e-13]j
[11.000000000000 +/- 1.43e-13] + [+/- 1.22e-13]j
>>> sum(acb.dft(acb.dft(range(1,10001)), inverse=True)).contains(50005000)
True

digamma(s)

Digamma function \(\psi(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).digamma(), dps=25)
0.7145915153739775266568699 + 1.320807282642230228386088j

dirichlet_eta(s)

Dirichlet eta function \(\eta(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1).dirichlet_eta(), dps=25)
0.6931471805599453094172321
>>> showgood(lambda: acb(0).dirichlet_eta(), dps=25)
0.5000000000000000000000000
>>> showgood(lambda: acb(0.5+10000j).dirichlet_eta(), dps=25)
-0.08240476492345768707759740 - 0.4458305781469329610368705j

dirichlet_l(s, chi)

ei(s)

Exponential integral \(\operatorname{Ei}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).ei(), dps=25)
2492.228976241877759138440

elliptic_e(m)

Complete elliptic integral of the second kind \(E(m)\).

>>> from flint import showgood
>>> showgood(lambda: 2 * acb(0).elliptic_e(), dps=25)
3.141592653589793238462643
>>> showgood(lambda: acb(100+50j).elliptic_e(), dps=25)
2.537235535915583230880553 - 10.10997759792420947130321j
>>> showgood(lambda: (1 - acb("1e-100")).elliptic_e(), dps=25)
1.000000000000000000000000

static elliptic_e_inc(phi, m, bool pi=False)

Incomplete elliptic integral \(E(\phi,m)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_e_inc(2, 0.75), dps=25)
1.443433069099461566497882
>>> showgood(lambda: acb.elliptic_e_inc(2, 0.75, pi=True), dps=25)
4.844224110273838099214252

static elliptic_f(phi, m, bool pi=False)

Incomplete elliptic integral \(F(\phi,m)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_f(2, 0.75), dps=25)
2.952569673655779502336268
>>> showgood(lambda: acb.elliptic_f(2, 0.75, pi=True), dps=25)
8.626062589998572941754700

elliptic_inv_p(self, tau)

Inverse Weierstrass elliptic function \(\sigma^{-1}(z, \tau)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb("1/3","1/5").elliptic_p(1j).elliptic_inv_p(1j), dps=25)
0.3333333333333333333333333 + 0.2000000000000000000000000j

elliptic_invariants(tau)

Returns the lattice invariants \(g_2, g_3\) given the lattice parameter \(\tau\).

>>> from flint import showgood
>>> showgood(lambda: acb(0.5+1j).elliptic_invariants(), dps=25)
(72.64157667926127619414883, 536.6642788346023116199232)

elliptic_k(m)

Complete elliptic integral of the first kind \(K(m)\).

>>> from flint import showgood
>>> showgood(lambda: 2 * acb(0).elliptic_k(), dps=25)
3.141592653589793238462643
>>> showgood(lambda: acb(100+50j).elliptic_k(), dps=25)
0.2052037361984861505113972 + 0.3158446040520529200980591j
>>> showgood(lambda: (1 - acb("1e-100")).elliptic_k(), dps=25)
116.5155490108221748197340

elliptic_p(self, tau)

Weierstrass elliptic function \(\wp(z, \tau)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb("1/3","1/5").elliptic_p(1j), dps=25)
3.686380646078879780287811 - 4.591498371497259422829963j
>>> showgood(lambda: acb("1/3","6/5").elliptic_p(1j), dps=25)
3.686380646078879780287811 - 4.591498371497259422829963j

static elliptic_pi(n, m)

Complete elliptic integral \(\Pi(n,m)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_pi(0.25, 0.125), dps=25)
1.879349451879603826415650

static elliptic_pi_inc(n, phi, m, bool pi=False)

Incomplete elliptic integral \(\Pi(n,\phi,m)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_pi_inc(0.25, 0.5, 0.125), dps=25)
0.5128718023282086251399279
>>> showgood(lambda: acb.elliptic_pi_inc(0.25, 0.5, 0.125, pi=True), dps=25)
1.879349451879603826415650

static elliptic_rc(x, y)

Carlson incomplete elliptic integral \(R_C(x,y)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_rc(1, 2+3j), dps=25)
0.5952169239306156198937085 - 0.2387981909090509407085918j

static elliptic_rd(x, y, z)

Carlson incomplete elliptic integral \(R_D(x,y,z)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_rd(1, 2, 1+2j), dps=25)
0.2043722510302629773408686 - 0.3559745898273715996616328j

static elliptic_rf(x, y, z)

Carlson incomplete elliptic integral \(R_F(x,y,z)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_rf(1, 2+3j, 3+4j), dps=25)
0.5577655465453921610327459 - 0.2202042457195556054465308j

static elliptic_rg(x, y, z)

Carlson incomplete elliptic integral \(R_G(x,y,z)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_rg(1, 2, 1+2j), dps=25)
1.206557168056722980475052 + 0.2752176688707739710008275j

static elliptic_rj(x, y, z, p)

Carlson incomplete elliptic integral \(R_J(x,y,z,p)\).

>>> from flint import showgood
>>> showgood(lambda: acb.elliptic_rj(1, 2, 1+2j, 2+3j), dps=25)
0.1604659632144333057202530 - 0.2502751672723324201692394j

elliptic_roots(tau)

Returns the elliptic roots \(e_1, e_2, e_3\) given the lattice parameter \(\tau\).

>>> from flint import showgood
>>> showgood(lambda: acb(0.5+1j).elliptic_roots(), dps=10)
(6.285388119, -3.142694059 + 3.386618325j, -3.142694059 - 3.386618325j)

elliptic_sigma(self, tau)

Weierstrass elliptic function \(\sigma(z, \tau)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb("1/3","1/5").elliptic_sigma(1j), dps=25)
0.3396549497136886526515370 + 0.1970690762350931272896772j

elliptic_zeta(self, tau)

Weierstrass elliptic function \(\zeta(z, \tau)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb("1/3","1/5").elliptic_zeta(1j), dps=25)
2.219680339508418716159086 - 1.504947925755241700681002j

erf(s)

Error function \(\operatorname{erf}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).erf() - 1, dps=25)
-21.82946142761456838910309 + 8.687318271470163144428079j
>>> showgood(lambda: acb("77.7").erf() - 1, dps=25, maxdps=10000)
-7.929310690520378873143053e-2625

erfc(s)

Complementary error function \(\operatorname{erfc}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb("77.7").erfc(), dps=25)
7.929310690520378873143053e-2625

erfi(s)

Imaginary error function \(\operatorname{erfi}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).erfi(), dps=25)
1.524307422708669699360547e+42

exp(s)

Exponential function \(\exp(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).exp(), dps=25)
-1.131204383756813638431255 + 2.471726672004818927616931j

exp_pi_i(s)

Exponential function of modified argument \(\exp(\pi i s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).exp_pi_i(), dps=25)
-0.001867442731707988814430213
>>> showgood(lambda: acb(1.5,2.5).exp_pi_i(), dps=25)
-0.0003882032039267662472325299j
>>> showgood(lambda: acb(1.25,2.25).exp_pi_i(), dps=25)
-0.0006020578259597635239581705 - 0.0006020578259597635239581705j

expint(self, s)

Generalized exponential integral \(E_s(z)\). The argument z is given by self and the order s is passed as an extra parameter.

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).expint(1+2j), dps=25)
-0.01442661495527080336037156 + 0.01942348372986687164972794j

expm1(s)

Exponential function \(\exp(s)-1\), computed accurately for small s.

>>> from flint import showgood
>>> showgood(lambda: acb("1e-10000").expm1(), dps=25)
1.000000000000000000000000e-10000

fresnel_c(s, bool normalized=True)

Fresnel cosine integral \(C(s)\), optionally not normalized.

>>> from flint import showgood
>>> showgood(lambda: acb(3).fresnel_c(), dps=25)
0.6057207892976856295561611
>>> showgood(lambda: acb(3).fresnel_c(normalized=False), dps=25)
0.7028635577302687301744099

fresnel_s(s, bool normalized=True)

Fresnel sine integral \(S(s)\), optionally not normalized.

>>> from flint import showgood
>>> showgood(lambda: acb(3).fresnel_s(), dps=25)
0.4963129989673750360976123
>>> showgood(lambda: acb(3).fresnel_s(normalized=False), dps=25)
0.7735625268937690171497722

gamma(s)

Gamma function \(\Gamma(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).gamma(), dps=25)
0.1519040026700361374481610 + 0.01980488016185498197191013j

gamma_lower(self, s, int regularized=0)

Lower incomplete gamma function \(\gamma(s,z)\). The argument z is given by self and the order s is passed as an extra parameter. Optionally the regularized versions \(P(s,z)\) and \(\gamma^{*}(s,z) = z^{-s} P(s,z)\) can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).gamma_lower(2.5), dps=25)
1.646077010134876664349297 + 1.140585862703100904414519j
>>> showgood(lambda: acb(2+3j).gamma_lower(2.5, regularized=1), dps=25)
1.238266003780709160156983 + 0.8580088838385611055576971j
>>> showgood(lambda: acb(2+3j).gamma_lower(2.5, regularized=2), dps=25)
-0.01687942194354244633506487 - 0.05864800341005793099108467j

gamma_upper(self, s, int regularized=0)

Upper incomplete gamma function \(\Gamma(s,z)\). The argument z is given by self and the order s is passed as an extra parameter. Optionally the regularized version \(Q(s,z)\) can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).gamma_upper(1+2j), dps=25)
0.02614303924198793235765248 - 0.0007536537278463329391666679j
>>> showgood(lambda: acb(2+3j).gamma_upper(1+2j, regularized=True), dps=25)
0.1685897763996036749499208 - 0.02694171301624093921683609j

gegenbauer_c(s, n, m)

Gegenbauer function \(C_n^{m}(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).gegenbauer_c(5, 0.25), dps=25)
0.1321855709876543209876543

hermite_h(s, n)

Hermite function \(H_n(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).hermite_h(5), dps=25)
34.20576131687242798353909

hypgeom(self, a, b, bool regularized=False, long n=-1)

Generalized hypergeometric function \({}_pF_q(a;b;z)\). The argument z is given by self and a and b are additional lists of complex numbers defining the parameters. Optionally the regularized hypergeometric function can be computed.

>>> from flint import fmpq
>>> from flint import showgood
>>> showgood(lambda: acb.pi().hypgeom([1+1j, 2-2j], [3, fmpq(1,3)]), dps=25)  # 2F2
144.9760711583421645394627 - 51.06535684838559608699106j
>>> showgood(lambda: acb.pi().hypgeom([1+1j, 2-2j], [3, fmpq(1,3)], regularized=True), dps=25)
27.05849150326959272369764 - 9.530893707861133993129862j

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.

hypgeom_0f1(self, a, bool regularized=False)

Hypergeometric function \({}_0F_1(a,z)\) where the argument z is given by self Optionally the regularized version of this function can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(-5).hypgeom_0f1(2.5), dps=25)
0.003114611044402738470826907
>>> showgood(lambda: acb(-5).hypgeom_0f1(2.5, regularized=True), dps=25)
0.002342974810739764377177885

hypgeom_1f1(self, a, b, bool regularized=False)

Kummer’s confluent hypergeometric function \({}_1F_1(a,b,z)\) where z is given by self.. Optionally, computes the regularized version.

>>> from flint import showgood
>>> showgood(lambda: acb(40000+50000j).hypgeom_1f1(2+3j, 3+4j), dps=25)
3.730925582634533963357515e+17366 + 3.199717318207534638202987e+17367j
>>> showgood(lambda: acb(40000+50000j).hypgeom_1f1(2+3j, 3+4j) / acb(3+4j).gamma(), dps=25)
-1.846160890579724375436801e+17368 + 2.721369772032882467996588e+17367j
>>> showgood(lambda: acb(10).hypgeom_1f1(5, -3, regularized=True), dps=25)
832600407043.6938843410086
>>> showgood(lambda: acb(10).hypgeom_1f1(-5,-6), dps=25)
403.7777777777777777777778
>>> showgood(lambda: acb(10).hypgeom_1f1(-5,-5,regularized=True), dps=25)
0
>>> showgood(lambda: acb(10).hypgeom_1f1(-5,-6,regularized=True), dps=25)
0
>>> showgood(lambda: acb(10).hypgeom_1f1(-5,-4,regularized=True), dps=25)
-100000.0000000000000000000

hypgeom_2f1(self, a, b, c, bool regularized=False, bool ab=False, bool ac=False, bc=False, abc=False)

The hypergeometric function \({}_2F_1(a,b,c,z)\) where the argument z is given by self Optionally the regularized version of this function can be computed.

>>> from flint import showgood
>>> showgood(lambda: acb(5).hypgeom_2f1(1,2,3), dps=25)
-0.5109035488895912495067571 - 0.2513274122871834590770115j
>>> showgood(lambda: acb(5).hypgeom_2f1(1,2,3,regularized=True), dps=25)
-0.2554517744447956247533786 - 0.1256637061435917295385057j

The flags ab, ac, bc, abc can be used to specify whether the parameter differences \(a-b\), \(a-c\), \(b-c\) and \(a+b-c\) represent exact integers, even if the input intervals are inexact. If the parameters are exact, these flags are not needed.

>>> from flint import arb
>>> from flint import showgood
>>> showgood(lambda: acb("11/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5, abc=True), dps=25)
1.801782659480054173351004 - 0.3114019850045849100659641j
>>> showgood(lambda: acb("11/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5), dps=25)
Traceback (most recent call last):
  ...
ValueError: no convergence (maxprec=960, try higher maxprec)

hypgeom_u(self, a, b, long n=-1, bool asymp=False)

Tricomi’s confluent hypergeometric function \(U(a,b,z)\) where z is given by self.

If asymp is set to True the asymptotic series is forced. If \(|z|\) is small, the attainable accuracy is then limited. The optional parameter n, if nonnegative, controls the number of terms to add in the asymptotic series. This is just a tuning parameter: a rigorous error bound is computed regardless of n.

>>> from flint import showgood
>>> showgood(lambda: acb(400+500j).hypgeom_u(1+1j, 2+3j), dps=25)
0.001836433961463105354717547 - 0.003358699641979853540147122j
>>> showgood(lambda: acb(-30).hypgeom_u(1+1j, 2+3j), dps=25)
0.7808944974399200669072087 - 0.2674783064947089569672470j
>>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=0, asymp=True))
[+/- 3.41] + [+/- 3.41]j
>>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=30, asymp=True))
[0.7808944974 +/- 7.46e-11] + [-0.2674783065 +/- 3.31e-11]j
>>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=60, asymp=True))
[0.78089 +/- 8.14e-6] + [-0.26748 +/- 5.34e-6]j

imag

static integral(func, a, b, params=None, rel_tol=None, abs_tol=None, deg_limit=None, eval_limit=None, depth_limit=None, use_heap=None, verbose=None)

Computes the integral \(\int_a^b f(x) dx\) where the integrand f is defined by func.

>>> from flint import arb
>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda x, _: x.sin(), 0, arb.pi()), dps=25)
2.000000000000000000000000
>>> showgood(lambda: acb.integral(lambda x, _: (x + x.sin()).gamma(), 1, 1+1j), dps=25)
-0.2732681890680958866139676 + 0.7064496061603478580993410j

The function func takes two parameters as input: the argument x and a boolean flag analytic. If analytic is False, func should return \(f(x)\), and in this case there are no restrictions on f; for instance, the integrand can be discontinuous on x. If analytic is True, func must verify that f is analytic on x, and if not, return a non-finite ball instead of \(f(x)\).

The analytic flag can be ignored for meromorphic functions, because evaluation at poles automatically leads to non-finite balls. However, it must be checked for functions that are non-analytic in some regions (for instance, functions with branch cuts such as \(\sqrt{x}\) and \(\log(x)\)), even if the integration path does not touch any non-analytic points. Some methods have an analytic option built-in, so the user simply has to forward this flag:

>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda x, _: x.sqrt(), 1, 4), dps=25)  # WRONG!!!
4.669414894781006338774348
>>> showgood(lambda: acb.integral(lambda x, a: x.sqrt(analytic=a), 1, 4), dps=25)  # correct
4.666666666666666666666667

The following works without handling the analytic flag, because the integrand is meromorphic:

>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda x, _: x.sech(), -1000, 1000), dps=25)
3.141592653589793238462643

The options rel_tol and abs_tol specify the relative and absolute tolerance goal for the integration. Both default to \(2^{-p}\) where p is the current precision.

The options deg_limit, eval_limit, depth_limit and use_heap allow control over the amount of work done before aborting; see the documentation for acb_calc_integrate for details.

is_exact(self) → bool

is_finite(self) → bool

is_zero(self) → bool

jacobi_p(s, n, a, b)

Jacobi polynomial (or Jacobi function) \(P_n^{a,b}(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).jacobi_p(5, 0.25, 0.5), dps=25)
0.4131944444444444444444444

laguerre_l(s, n, m=0)

Laguerre function \(L_n^{m}(s)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).laguerre_l(5, 0.25), dps=25)
0.03871323490012002743484225

lambertw(s, branch=0, bool left=False, bool middle=False)

Lambert W function, \(W_k(s)\) where k is given by branch.

>>> from flint import showgood
>>> showgood(lambda: acb(1).lambertw(), dps=25)
0.5671432904097838729999687
>>> showgood(lambda: acb(1).lambertw(-1), dps=25)
-1.533913319793574507919741 - 4.375185153061898385470907j
>>> showgood(lambda: acb(1).lambertw(-2), dps=25)
-2.401585104868002884174140 - 10.77629951611507089849710j

The branch cuts follow Corless et al. by default. This function allows selecting alternative branch cuts in order to support continuous analytic continuation on complex intervals.

If left is set, computes \(W_{\mathrm{left}|k}(z)\) which corresponds to \(W_k(z)\) in the upper half plane and \(W_{k+1}(z)\) in the lower half plane, connected continuously to the left of the branch points. In other words, the branch cut on \((-\infty,0)\) is rotated counterclockwise to \((0,+\infty)\). (For \(k = -1\) and \(k = 0\), there is also a branch cut on \((-1/e,0)\), continuous from below instead of from above to maintain counterclockwise continuity.)

If middle is set, computes \(W_{\mathrm{middle}}(z)\) which corresponds to \(W_{-1}(z)\) in the upper half plane and \(W_{1}(z)\) in the lower half plane, connected continuously through \((-1/e,0)\) with branch cuts on \((-\infty,-1/e)\) and \((0,+\infty)\). \(W_{\mathrm{middle}}(z)\) extends the real analytic function \(W_{-1}(x)\) defined on \((-1/e,0)\) to a complex analytic function, whereas the standard branch \(W_{-1}(z)\) has a branch cut along the real segment.

>>> acb(-5,"+/- 1e-20").lambertw()
[0.844844605432170 +/- 6.18e-16] + [+/- 1.98]j
>>> acb(-5,"+/- 1e-20").lambertw(left=True)
[0.844844605432170 +/- 7.85e-16] + [1.97500875488903 +/- 4.05e-15]j
>>> acb(-5,"+/- 1e-20").lambertw(-1, left=True)
[0.844844605432170 +/- 7.85e-16] + [-1.97500875488903 +/- 4.05e-15]j
>>> acb(-0.25,"+/- 1e-20").lambertw(middle=True)
[-2.15329236411035 +/- 1.48e-15] + [+/- 4.87e-16]j

legendre_p(s, n, m=0, int type=2)

Legendre function of the first kind \(P_n^m(z)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).legendre_p(5), dps=25)
0.3333333333333333333333333
>>> showgood(lambda: (acb(1)/3).legendre_p(5, 1.5), dps=25)
-2.372124991643971726805456
>>> showgood(lambda: (acb(3)).legendre_p(5, 1.5, type=2), dps=25)
-12091.31397811720689120900 - 12091.31397811720689120900j
>>> showgood(lambda: (acb(3)).legendre_p(5, 1.5, type=3), dps=25)
17099.70021476473458984981

The optional parameter type can be 2 or 3, and selects between two different branch cut conventions (see Mathematica and mpmath).

legendre_q(s, n, m=0, int type=2)

Legendre function of the second kind \(Q_n^m(z)\).

>>> from flint import showgood
>>> showgood(lambda: (acb(1)/3).legendre_q(5), dps=25)
0.1655245300933242182362054
>>> showgood(lambda: (acb(1)/3).legendre_q(5, 1.5), dps=25)
-6.059967350218583975575616
>>> showgood(lambda: (acb(3)).legendre_q(5, 1.5, type=2), dps=25)
-18992.99179585607569083751 + 18992.99179585607569083751j
>>> showgood(lambda: (acb(3)).legendre_q(5, 1.5, type=3), dps=25)
-0.0003010942389043591251820434j

The optional parameter type can be 2 or 3, and selects between two different branch cut conventions (see Mathematica and mpmath).

lerch_phi(z, s, a)

Lerch transcendent \(\Phi(z,s,a)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).lerch_phi(3, 4), dps=25)
0.006872751459699249251487346 + 0.01112535314686351879432212j

lgamma(s)

Logarithmic gamma function \(\log \Gamma(s)\). The function is defined to be continuous away from the negative half-axis and thus differs from \(\log(\Gamma(s))\) in general.

>>> from flint import arb
>>> from flint import showgood
>>> showgood(lambda: acb(1,2).lgamma(), dps=25)
-1.876078786430929341229996 + 0.1296463163097883113837075j
>>> showgood(lambda: (acb(0,10).lgamma() - acb(0,10).gamma().log()).imag / arb.pi(), dps=25)
4.000000000000000000000000

li(s, bool offset=False)

Logarithmic integral \(\operatorname{li}(s)\), optionally the offset logarithmic integral \(\operatorname{Li}(s) = \operatorname{li}(s) - \operatorname{li}(2)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).li(), dps=25)
6.165599504787297937522982
>>> showgood(lambda: acb(10).li(offset=True), dps=25)
5.120435724669805152678393

log(s, bool analytic=False)

Natural logarithm \(\log(s)\). The analytic flag allows verifying that the branch cut is not touched; this is useful for numerical integration.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).log(), dps=25)
0.8047189562170501873003797 + 1.107148717794090503017065j
>>> showgood(lambda: acb(-5).log(), dps=25)
1.609437912434100374600759 + 3.141592653589793238462643j

log1p(s)

Computes \(\log(1+s)\), accurately for small s.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).log1p(), dps=25)
1.039720770839917964125848 + 0.7853981633974483096156608j
>>> showgood(lambda: acb(0,"1e-100000000000000000").log1p(), dps=25)
5.000000000000000000000000e-200000000000000001 + 1.000000000000000000000000e-100000000000000000j

log_barnes_g(s)

Logarithmic Barnes G-function \(\log G(s)\). Like the logarithmic gamma function, continuous analytic continuation is implied.

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).log_barnes_g(), dps=25)
-1.694395396880976849503750 - 3.389316783507118550918827j
>>> showgood(lambda: acb(2+3j).barnes_g().log(), dps=25)
-1.694395396880976849503750 + 2.893868523672467926006460j

log_sin_pi(s)

Logarithmic sine function with analytic continuation defined to be consistent with the functional equation of the log gamma function.

>>> from flint import showgood
>>> showgood(lambda: acb(5+2j).log_sin_pi(), dps=25)
5.590034639271204166020651 - 14.13716694115406957308190j
>>> showgood(lambda: acb(5+2j).sin_pi().log(), dps=25)
5.590034639271204166020651 - 1.570796326794896619231322j

mid(self)

Returns an exact acb representing the midpoint of self:

>>> acb("1 +/- 0.3", "2 +/- 0.4").mid()
1.00000000000000 + 2.00000000000000j

modular_delta(tau)

Modular discriminant \(\Delta(\tau)\).

>>> from flint import showgood
>>> showgood(lambda: acb(0.25+5j).modular_delta(), dps=25)
1.237896015010281684100435e-26 + 2.271101068324093838679275e-14j

modular_eta(tau)

Dedekind eta function \(\eta(\tau)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1+1j).modular_eta(), dps=25)
0.7420487758365647263392722 + 0.1988313702299107190516142j

modular_j(tau)

Modular j-invariant \(j(\tau)\).

>>> from flint import showgood
>>> showgood(lambda: (1 + acb(-163).sqrt()/2).modular_j(), dps=25)
262537412640769488.0000000
>>> showgood(lambda: acb(3.25+100j).modular_j() - 744, dps=25, maxdps=2000)
-3.817428033843319485125773e-539 - 7.503618895582604309279721e+272j

modular_lambda(tau)

Modular lambda function \(\lambda(\tau)\).

>>> from flint import showgood
>>> showgood(lambda: acb(0.25+5j).modular_lambda(), dps=25)
1.704995415668039343330405e-6 + 1.704992508662079437786598e-6j

modular_theta(z, tau, ulong r=0)

Computes the Jacobi theta functions \(\theta_1(z,\tau)\), \(\theta_2(z,\tau)\), \(\theta_3(z,\tau)\), \(\theta_4(z,\tau)\), returning all four values as a tuple. We define the theta functions with a factor \(\pi\) for z included; for example \(\theta_3(z,\tau) = 1 + 2 \sum_{n=1}^{\infty} q^{n^2} \cos(2n\pi z)\).

>>> from flint import showgood
>>> for i in range(4):
...     showgood(lambda: acb(1+1j).modular_theta(1.25+3j)[i], dps=25)
...
1.820235910124989594900076 - 1.216251950154477951760042j
-1.220790267576967690128359 - 1.827055516791154669091679j
0.9694430387796704100046143 - 0.03055696120816803328582847j
1.030556961196006476576271 + 0.03055696120816803328582847j

neg(self, bool exact=False)

overlaps(self, other)

static pi()

Returns the constant \(\pi\) as an acb.

>>> from flint import showgood
>>> showgood(lambda: acb.pi(), dps=25)
3.141592653589793238462643

polygamma(self, s)

Polygamma function \(\psi_s(z)\) where z is given by self.

>>> from flint import showgood
>>> showgood(lambda: acb(2+3j).polygamma(2), dps=25)
0.05267618908093586035755719 + 0.07303622933440580692454450j

polylog(self, s)

Computes the polylogarithm \(\operatorname{Li}_s(z)\) where the argument z is given by self and the order s is given as an extra parameter.

>>> from flint import showgood
>>> showgood(lambda: acb(3).polylog(2), dps=25)
2.320180423313098396406194 - 3.451392295223202661433821j
>>> showgood(lambda: acb(2,3).polylog(1+2j), dps=25)
-6.854984251829306907116775 + 7.375884252099214498443165j

pow(s, t, bool analytic=False)

Power \(s^t\). The analytic flag allows verifying that the branch cut is not touched; this is useful for numerical integration.

>>> acb.integral(lambda z, a: z.pow(acb("1/3")), -5-1j, -5+1j)  # WRONG!!!
[+/- 5.03e-15] + [1.81137435753228 +/- 7.32e-15]j
>>> acb.integral(lambda z, a: z.pow(acb("1/3"), analytic=a), -5-1j, -5+1j)
[+/- 2.66e-14] + [1.8108516218463 +/- 3.58e-14]j

rad(self)

Returns an upper bound for the radius (magnitude of error) of self as an arb.

>>> print(acb("1 +/- 0.3", "2 +/- 0.4").rad().str(5, radius=False))
0.50000

real

real_abs(s, bool analytic=False)

Absolute value of a real variable, extended to a piecewise complex analytic function. This function is useful for integration.

>>> f = lambda z, a: (z**3).real_abs(analytic=a)
>>> from flint import showgood
>>> showgood(lambda: acb.integral(f, -1, 1), dps=25)
0.5000000000000000000000000

real_ceil(s, bool analytic=False)

Ceiling function of a real variable, extended to a piecewise complex analytic function. This function is useful for integration.

>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda x, a: x.real_ceil(analytic=a), 0, 100), dps=15)
5050.00000000000

real_floor(s, bool analytic=False)

Floor function of a real variable, extended to a piecewise complex analytic function. This function is useful for integration.

>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda x, a: x.real_floor(analytic=a), 0, 100), dps=15)
4950.00000000000

real_heaviside(s, bool analytic=False)

Heaviside step function of a real variable, extended to a piecewise complex analytic function. This function is useful for integration.

>>> acb(-5+2j).real_heaviside(analytic=True)
0
>>> acb(5+2j).real_heaviside(analytic=True)
1.00000000000000
>>> acb(0).real_heaviside(analytic=True)
nan + nanj
>>> acb(0).real_heaviside()
0.500000000000000

real_max(s, t, bool analytic=False)

Maximum value of two real variables, extended to a piecewise complex analytic function. This function is useful for integration.

>>> f = lambda x, a: x.sin().real_max(x.cos(), analytic=a)
>>> from flint import showgood
>>> showgood(lambda: acb.integral(f, 0, acb.pi()))
2.41421356237310

real_min(s, t, bool analytic=False)

Minimum value of two real variables, extended to a piecewise complex analytic function. This function is useful for integration.

>>> f = lambda x, a: x.sin().real_min(x.cos(), analytic=a)
>>> from flint import showgood
>>> showgood(lambda: acb.integral(f, 0, acb.pi()))
-0.414213562373095

real_sgn(s, bool analytic=False)

Sign function of a real variable, extended to a piecewise complex analytic function. This function is useful for integration.

>>> acb(-5+2j).real_sgn()
-1.00000000000000
>>> acb(0).real_sgn()
0
>>> acb(0).real_sgn(analytic=True)
nan + nanj

real_sqrt(s, bool analytic=False)

Square root of a real variable assumed to be nonnegative, extended to a piecewise complex analytic function. This function is useful for integration.

>>> acb.integral(lambda x, a: x.sqrt(analytic=a), 0, 1)
[0.6666666666667 +/- 4.19e-14] + [+/- 1.12e-16]j
>>> acb.integral(lambda x, a: x.real_sqrt(analytic=a), 0, 1)
[0.6666666666667 +/- 4.19e-14]

rel_accuracy_bits(self)

rel_one_accuracy_bits(self)

repr(self)

rgamma(s)

Reciprocal gamma function \(1/\Gamma(s)\), avoiding division by zero at the poles of the gamma function.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).rgamma(), dps=25)
6.473073626019134501563613 - 0.8439438407732021454882999j
>>> print(acb(0).rgamma())
0
>>> print(acb(-1).rgamma())
0

rising(s, n)

Rising factorial \((s)_n\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).rising(5), dps=25)
-540.0000000000000000000000 - 100.0000000000000000000000j
>>> showgood(lambda: acb(1,2).rising(2+3j), dps=25)
0.3898076751098812033498554 - 0.01296289149274537721607465j

rising2(s, ulong n)

Computes the rising factorial \((s)_n\) where n is an unsigned integer, along with the first derivative with respect to \((s)_n\). The current implementation does not use the gamma function, so n should be moderate.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).rising2(5), dps=25)
(-540.0000000000000000000000 - 100.0000000000000000000000j, -666.0000000000000000000000 + 420.0000000000000000000000j)

root(s, ulong n)

Principal n-th root of s.

>>> from flint import showgood
>>> showgood(lambda: acb(-1).root(3), dps=25)
0.5000000000000000000000000 + 0.8660254037844386467637232j
>>> showgood(lambda: acb(10,11).root(3), dps=25)
2.364674532267765964410078 + 0.6739866114818132500777466j

rsqrt(s, bool analytic=False)

Reciprocal square root \(1/\sqrt{s}\).

The analytic flag allows verifying that the branch cut is not touched; this is useful for numerical integration.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).rsqrt(), dps=25)
0.5688644810057831072783079 - 0.3515775842541429284870573j

sec(s)

Secant function \(\sec(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).sec(), dps=25)
-0.04167496441114427004834991 + 0.09061113719623759652966120j

sech(s)

Hyperbolic secant function \(\operatorname{sech}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).sech(), dps=25)
-0.2635129751583893096436042 - 0.03621163655876852087145690j

sgn(self)

Complex sign function.

>>> from flint import showgood
>>> showgood(lambda: acb(-1).sgn(), dps=25)
-1.000000000000000000000000
>>> showgood(lambda: acb(5,5).sgn(), dps=25)
0.7071067811865475244008444 + 0.7071067811865475244008444j
>>> showgood(lambda: acb(0).sgn(), dps=25)
0

shi(s)

Hyperbolic sine integral \(\operatorname{Shi}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).shi(), dps=25)
1246.114490199423344411882

si(s)

Sine integral \(\operatorname{Si}(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(10).si(), dps=25)
1.658347594218874049330972

sin(s)

Sine function \(\sin(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sin(), dps=25)
3.165778513216168146740735 + 1.959601041421605897070352j

sin_cos(s)

Computes \(\sin(s)\) and \(\cos(s)\) simultaneously.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sin_cos(), dps=15)
(3.16577851321617 + 1.95960104142161j, 2.03272300701967 - 3.05189779915180j)

sin_cos_pi(s)

Computes \(\sin(\pi s)\) and \(\cos(\pi s)\) simultaneously.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sin_cos_pi(), dps=25)
(-267.7448940410165142571174j, -267.7467614837482222459319)

sin_pi(s)

Sine function \(\sin(\pi s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sin_pi(), dps=25)
-267.7448940410165142571174j

sinc(s)

Sinc function, \(\operatorname{sinc}(x) = \sin(x)/x\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).sinc(), dps=25)
0.4463290318402435457438585 - 2.753947027743647493993194j

sinc_pi(s)

Normalized sinc function, \(\operatorname{sinc}(\pi x) = \sin(\pi x)/(\pi x)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).sinc_pi(), dps=25)
455.1212281938610260024088 + 303.4141521292406840016059j

sinh(s)

Hyperbolic sine function \(\sinh(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).sinh(), dps=25)
-3.590564589985779952012565 + 0.5309210862485198052670401j

sinh_cosh(s)

Computes \(\sinh(s)\) and \(\cosh(s)\) simultaneously.

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sinh_cosh(), dps=15)
(-0.489056259041294 + 1.40311925062204j, -0.642148124715520 + 1.06860742138278j)

static spherical_y(long n, long m, theta, phi)

Spherical harmonic \(Y_n^m(\theta, \phi)\). The present implementation only supports integer n and m.

>>> from flint import showgood
>>> showgood(lambda: acb.spherical_y(5, 3, 0.25, 0.75), dps=25)
0.02451377199072374024317003 - 0.03036343496553117039110087j

sqrt(s, bool analytic=False)

Square root \(\sqrt{s}\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).sqrt(), dps=25)
1.272019649514068964252422 + 0.7861513777574232860695586j

The analytic flag allows verifying that the branch cut is not touched; this is useful for numerical integration.

>>> from flint import showgood
>>> showgood(lambda: acb.integral(lambda z, a: z.sqrt(), 0, 1).real, dps=25)  # WRONG!!!
0.6738873386790491615691993
>>> showgood(lambda: acb.integral(lambda z, a: z.sqrt(analytic=a), 0, 1).real, dps=25)
0.6666666666666666666666667

static stieltjes(n, a=1)

Generalized Stieltjes constant \(\gamma_n(a)\).

>>> from flint import showgood
>>> showgood(lambda: acb.stieltjes(1), dps=25)
-0.07281584548367672486058638
>>> showgood(lambda: acb.stieltjes(10**10), dps=25)
7.588362123713105194822403e+12397849705
>>> showgood(lambda: acb.stieltjes(1000, 2+3j), dps=25)
-1.206122870741999199264747e+494 - 1.389205283963836265123849e+494j

str(self, *args, **kwargs)

tan(s)

Tangent function \(\tan(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).tan(), dps=25)
0.03381282607989669028437056 + 1.014793616146633568117054j

tan_pi(s)

Tangent function \(\tan(\pi s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(1,2).tan_pi(), dps=25)
0.9999930253396106106051072j

tanh(s)

Hyperbolic tangent function \(\tanh(s)\).

>>> from flint import showgood
>>> showgood(lambda: acb(2,3).tanh(), dps=25)
0.9653858790221331242784803 - 0.009884375038322493720314034j

union(s, t)

unique_fmpz(self)

If self represents exactly one integer, returns this value as an fmpz; otherwise returns None.

>>> acb("5 +/- 0.1").unique_fmpz()
5
>>> acb("5 +/- 0.9", "10 +/- 11").unique_fmpz()
5
>>> acb("5 +/- 0.9", 11).unique_fmpz()
>>>
>>> acb("5.1 +/- 0.9").unique_fmpz()
>>>

zeta(s, a=None)

Riemann zeta function \(\zeta(s)\), or the Hurwitz zeta function \(\zeta(s,a)\) if a second parameter is passed.

>>> from flint import showgood
>>> showgood(lambda: acb(0.5,1000).zeta(), dps=25)
0.3563343671943960550744025 + 0.9319978312329936651150604j
>>> showgood(lambda: acb(1,2).zeta(acb(2,3)), dps=25)
-2.953059572088556722876240 + 3.410962524512050603254574j

static zeta_zero(n)

Returns the n-th nontrivial zero of the Riemann zeta function.

>>> from flint import showgood
>>> showgood(lambda: acb.zeta_zero(1), dps=25)
0.5000000000000000000000000 + 14.13472514173469379045725j
>>> showgood(lambda: acb.zeta_zero(2), dps=25)
0.5000000000000000000000000 + 21.02203963877155499262848j
>>> showgood(lambda: acb.zeta_zero(100), dps=25)
0.5000000000000000000000000 + 236.5242296658162058024755j
>>> showgood(lambda: acb.zeta_zero(10**6), dps=25)
0.5000000000000000000000000 + 600269.6770124449555212339j

static zeta_zeros(n, long num)

Returns num consecutive nontrivial zeros of the Riemann zeta function starting at index n.

>>> for r in acb.zeta_zeros(1000, 10):
...     print(r.str(10, radius=False))
...
0.5000000000 + 1419.422481j
0.5000000000 + 1420.416526j
0.5000000000 + 1421.850567j
0.5000000000 + 1422.461311j
0.5000000000 + 1424.463046j
0.5000000000 + 1425.873469j
0.5000000000 + 1426.645980j
0.5000000000 + 1427.365671j
0.5000000000 + 1428.592306j
0.5000000000 + 1429.650477j