|
r""" |
|
Elliptic functions historically comprise the elliptic integrals |
|
and their inverses, and originate from the problem of computing the |
|
arc length of an ellipse. From a more modern point of view, |
|
an elliptic function is defined as a doubly periodic function, i.e. |
|
a function which satisfies |
|
|
|
.. math :: |
|
|
|
f(z + 2 \omega_1) = f(z + 2 \omega_2) = f(z) |
|
|
|
for some half-periods `\omega_1, \omega_2` with |
|
`\mathrm{Im}[\omega_1 / \omega_2] > 0`. The canonical elliptic |
|
functions are the Jacobi elliptic functions. More broadly, this section |
|
includes quasi-doubly periodic functions (such as the Jacobi theta |
|
functions) and other functions useful in the study of elliptic functions. |
|
|
|
Many different conventions for the arguments of |
|
elliptic functions are in use. It is even standard to use |
|
different parameterizations for different functions in the same |
|
text or software (and mpmath is no exception). |
|
The usual parameters are the elliptic nome `q`, which usually |
|
must satisfy `|q| < 1`; the elliptic parameter `m` (an arbitrary |
|
complex number); the elliptic modulus `k` (an arbitrary complex |
|
number); and the half-period ratio `\tau`, which usually must |
|
satisfy `\mathrm{Im}[\tau] > 0`. |
|
These quantities can be expressed in terms of each other |
|
using the following relations: |
|
|
|
.. math :: |
|
|
|
m = k^2 |
|
|
|
.. math :: |
|
|
|
\tau = i \frac{K(1-m)}{K(m)} |
|
|
|
.. math :: |
|
|
|
q = e^{i \pi \tau} |
|
|
|
.. math :: |
|
|
|
k = \frac{\vartheta_2^2(q)}{\vartheta_3^2(q)} |
|
|
|
In addition, an alternative definition is used for the nome in |
|
number theory, which we here denote by q-bar: |
|
|
|
.. math :: |
|
|
|
\bar{q} = q^2 = e^{2 i \pi \tau} |
|
|
|
For convenience, mpmath provides functions to convert |
|
between the various parameters (:func:`~mpmath.qfrom`, :func:`~mpmath.mfrom`, |
|
:func:`~mpmath.kfrom`, :func:`~mpmath.taufrom`, :func:`~mpmath.qbarfrom`). |
|
|
|
**References** |
|
|
|
1. [AbramowitzStegun]_ |
|
|
|
2. [WhittakerWatson]_ |
|
|
|
""" |
|
|
|
from .functions import defun, defun_wrapped |
|
|
|
@defun_wrapped |
|
def eta(ctx, tau): |
|
r""" |
|
Returns the Dedekind eta function of tau in the upper half-plane. |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> eta(1j); gamma(0.25) / (2*pi**0.75) |
|
(0.7682254223260566590025942 + 0.0j) |
|
0.7682254223260566590025942 |
|
>>> tau = sqrt(2) + sqrt(5)*1j |
|
>>> eta(-1/tau); sqrt(-1j*tau) * eta(tau) |
|
(0.9022859908439376463573294 + 0.07985093673948098408048575j) |
|
(0.9022859908439376463573295 + 0.07985093673948098408048575j) |
|
>>> eta(tau+1); exp(pi*1j/12) * eta(tau) |
|
(0.4493066139717553786223114 + 0.3290014793877986663915939j) |
|
(0.4493066139717553786223114 + 0.3290014793877986663915939j) |
|
>>> f = lambda z: diff(eta, z) / eta(z) |
|
>>> chop(36*diff(f,tau)**2 - 24*diff(f,tau,2)*f(tau) + diff(f,tau,3)) |
|
0.0 |
|
|
|
""" |
|
if ctx.im(tau) <= 0.0: |
|
raise ValueError("eta is only defined in the upper half-plane") |
|
q = ctx.expjpi(tau/12) |
|
return q * ctx.qp(q**24) |
|
|
|
def nome(ctx, m): |
|
m = ctx.convert(m) |
|
if not m: |
|
return m |
|
if m == ctx.one: |
|
return m |
|
if ctx.isnan(m): |
|
return m |
|
if ctx.isinf(m): |
|
if m == ctx.ninf: |
|
return type(m)(-1) |
|
else: |
|
return ctx.mpc(-1) |
|
a = ctx.ellipk(ctx.one-m) |
|
b = ctx.ellipk(m) |
|
v = ctx.exp(-ctx.pi*a/b) |
|
if not ctx._im(m) and ctx._re(m) < 1: |
|
if ctx._is_real_type(m): |
|
return v.real |
|
else: |
|
return v.real + 0j |
|
elif m == 2: |
|
v = ctx.mpc(0, v.imag) |
|
return v |
|
|
|
@defun_wrapped |
|
def qfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None): |
|
r""" |
|
Returns the elliptic nome `q`, given any of `q, m, k, \tau, \bar{q}`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> qfrom(q=0.25) |
|
0.25 |
|
>>> qfrom(m=mfrom(q=0.25)) |
|
0.25 |
|
>>> qfrom(k=kfrom(q=0.25)) |
|
0.25 |
|
>>> qfrom(tau=taufrom(q=0.25)) |
|
(0.25 + 0.0j) |
|
>>> qfrom(qbar=qbarfrom(q=0.25)) |
|
0.25 |
|
|
|
""" |
|
if q is not None: |
|
return ctx.convert(q) |
|
if m is not None: |
|
return nome(ctx, m) |
|
if k is not None: |
|
return nome(ctx, ctx.convert(k)**2) |
|
if tau is not None: |
|
return ctx.expjpi(tau) |
|
if qbar is not None: |
|
return ctx.sqrt(qbar) |
|
|
|
@defun_wrapped |
|
def qbarfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None): |
|
r""" |
|
Returns the number-theoretic nome `\bar q`, given any of |
|
`q, m, k, \tau, \bar{q}`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> qbarfrom(qbar=0.25) |
|
0.25 |
|
>>> qbarfrom(q=qfrom(qbar=0.25)) |
|
0.25 |
|
>>> qbarfrom(m=extraprec(20)(mfrom)(qbar=0.25)) # ill-conditioned |
|
0.25 |
|
>>> qbarfrom(k=extraprec(20)(kfrom)(qbar=0.25)) # ill-conditioned |
|
0.25 |
|
>>> qbarfrom(tau=taufrom(qbar=0.25)) |
|
(0.25 + 0.0j) |
|
|
|
""" |
|
if qbar is not None: |
|
return ctx.convert(qbar) |
|
if q is not None: |
|
return ctx.convert(q) ** 2 |
|
if m is not None: |
|
return nome(ctx, m) ** 2 |
|
if k is not None: |
|
return nome(ctx, ctx.convert(k)**2) ** 2 |
|
if tau is not None: |
|
return ctx.expjpi(2*tau) |
|
|
|
@defun_wrapped |
|
def taufrom(ctx, q=None, m=None, k=None, tau=None, qbar=None): |
|
r""" |
|
Returns the elliptic half-period ratio `\tau`, given any of |
|
`q, m, k, \tau, \bar{q}`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> taufrom(tau=0.5j) |
|
(0.0 + 0.5j) |
|
>>> taufrom(q=qfrom(tau=0.5j)) |
|
(0.0 + 0.5j) |
|
>>> taufrom(m=mfrom(tau=0.5j)) |
|
(0.0 + 0.5j) |
|
>>> taufrom(k=kfrom(tau=0.5j)) |
|
(0.0 + 0.5j) |
|
>>> taufrom(qbar=qbarfrom(tau=0.5j)) |
|
(0.0 + 0.5j) |
|
|
|
""" |
|
if tau is not None: |
|
return ctx.convert(tau) |
|
if m is not None: |
|
m = ctx.convert(m) |
|
return ctx.j*ctx.ellipk(1-m)/ctx.ellipk(m) |
|
if k is not None: |
|
k = ctx.convert(k) |
|
return ctx.j*ctx.ellipk(1-k**2)/ctx.ellipk(k**2) |
|
if q is not None: |
|
return ctx.log(q) / (ctx.pi*ctx.j) |
|
if qbar is not None: |
|
qbar = ctx.convert(qbar) |
|
return ctx.log(qbar) / (2*ctx.pi*ctx.j) |
|
|
|
@defun_wrapped |
|
def kfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None): |
|
r""" |
|
Returns the elliptic modulus `k`, given any of |
|
`q, m, k, \tau, \bar{q}`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> kfrom(k=0.25) |
|
0.25 |
|
>>> kfrom(m=mfrom(k=0.25)) |
|
0.25 |
|
>>> kfrom(q=qfrom(k=0.25)) |
|
0.25 |
|
>>> kfrom(tau=taufrom(k=0.25)) |
|
(0.25 + 0.0j) |
|
>>> kfrom(qbar=qbarfrom(k=0.25)) |
|
0.25 |
|
|
|
As `q \to 1` and `q \to -1`, `k` rapidly approaches |
|
`1` and `i \infty` respectively:: |
|
|
|
>>> kfrom(q=0.75) |
|
0.9999999999999899166471767 |
|
>>> kfrom(q=-0.75) |
|
(0.0 + 7041781.096692038332790615j) |
|
>>> kfrom(q=1) |
|
1 |
|
>>> kfrom(q=-1) |
|
(0.0 + +infj) |
|
""" |
|
if k is not None: |
|
return ctx.convert(k) |
|
if m is not None: |
|
return ctx.sqrt(m) |
|
if tau is not None: |
|
q = ctx.expjpi(tau) |
|
if qbar is not None: |
|
q = ctx.sqrt(qbar) |
|
if q == 1: |
|
return q |
|
if q == -1: |
|
return ctx.mpc(0,'inf') |
|
return (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**2 |
|
|
|
@defun_wrapped |
|
def mfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None): |
|
r""" |
|
Returns the elliptic parameter `m`, given any of |
|
`q, m, k, \tau, \bar{q}`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> mfrom(m=0.25) |
|
0.25 |
|
>>> mfrom(q=qfrom(m=0.25)) |
|
0.25 |
|
>>> mfrom(k=kfrom(m=0.25)) |
|
0.25 |
|
>>> mfrom(tau=taufrom(m=0.25)) |
|
(0.25 + 0.0j) |
|
>>> mfrom(qbar=qbarfrom(m=0.25)) |
|
0.25 |
|
|
|
As `q \to 1` and `q \to -1`, `m` rapidly approaches |
|
`1` and `-\infty` respectively:: |
|
|
|
>>> mfrom(q=0.75) |
|
0.9999999999999798332943533 |
|
>>> mfrom(q=-0.75) |
|
-49586681013729.32611558353 |
|
>>> mfrom(q=1) |
|
1.0 |
|
>>> mfrom(q=-1) |
|
-inf |
|
|
|
The inverse nome as a function of `q` has an integer |
|
Taylor series expansion:: |
|
|
|
>>> taylor(lambda q: mfrom(q), 0, 7) |
|
[0.0, 16.0, -128.0, 704.0, -3072.0, 11488.0, -38400.0, 117632.0] |
|
|
|
""" |
|
if m is not None: |
|
return m |
|
if k is not None: |
|
return k**2 |
|
if tau is not None: |
|
q = ctx.expjpi(tau) |
|
if qbar is not None: |
|
q = ctx.sqrt(qbar) |
|
if q == 1: |
|
return ctx.convert(q) |
|
if q == -1: |
|
return q*ctx.inf |
|
v = (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**4 |
|
if ctx._is_real_type(q) and q < 0: |
|
v = v.real |
|
return v |
|
|
|
jacobi_spec = { |
|
'sn' : ([3],[2],[1],[4], 'sin', 'tanh'), |
|
'cn' : ([4],[2],[2],[4], 'cos', 'sech'), |
|
'dn' : ([4],[3],[3],[4], '1', 'sech'), |
|
'ns' : ([2],[3],[4],[1], 'csc', 'coth'), |
|
'nc' : ([2],[4],[4],[2], 'sec', 'cosh'), |
|
'nd' : ([3],[4],[4],[3], '1', 'cosh'), |
|
'sc' : ([3],[4],[1],[2], 'tan', 'sinh'), |
|
'sd' : ([3,3],[2,4],[1],[3], 'sin', 'sinh'), |
|
'cd' : ([3],[2],[2],[3], 'cos', '1'), |
|
'cs' : ([4],[3],[2],[1], 'cot', 'csch'), |
|
'dc' : ([2],[3],[3],[2], 'sec', '1'), |
|
'ds' : ([2,4],[3,3],[3],[1], 'csc', 'csch'), |
|
'cc' : None, |
|
'ss' : None, |
|
'nn' : None, |
|
'dd' : None |
|
} |
|
|
|
@defun |
|
def ellipfun(ctx, kind, u=None, m=None, q=None, k=None, tau=None): |
|
try: |
|
S = jacobi_spec[kind] |
|
except KeyError: |
|
raise ValueError("First argument must be a two-character string " |
|
"containing 's', 'c', 'd' or 'n', e.g.: 'sn'") |
|
if u is None: |
|
def f(*args, **kwargs): |
|
return ctx.ellipfun(kind, *args, **kwargs) |
|
f.__name__ = kind |
|
return f |
|
prec = ctx.prec |
|
try: |
|
ctx.prec += 10 |
|
u = ctx.convert(u) |
|
q = ctx.qfrom(m=m, q=q, k=k, tau=tau) |
|
if S is None: |
|
v = ctx.one + 0*q*u |
|
elif q == ctx.zero: |
|
if S[4] == '1': v = ctx.one |
|
else: v = getattr(ctx, S[4])(u) |
|
v += 0*q*u |
|
elif q == ctx.one: |
|
if S[5] == '1': v = ctx.one |
|
else: v = getattr(ctx, S[5])(u) |
|
v += 0*q*u |
|
else: |
|
t = u / ctx.jtheta(3, 0, q)**2 |
|
v = ctx.one |
|
for a in S[0]: v *= ctx.jtheta(a, 0, q) |
|
for b in S[1]: v /= ctx.jtheta(b, 0, q) |
|
for c in S[2]: v *= ctx.jtheta(c, t, q) |
|
for d in S[3]: v /= ctx.jtheta(d, t, q) |
|
finally: |
|
ctx.prec = prec |
|
return +v |
|
|
|
@defun_wrapped |
|
def kleinj(ctx, tau=None, **kwargs): |
|
r""" |
|
Evaluates the Klein j-invariant, which is a modular function defined for |
|
`\tau` in the upper half-plane as |
|
|
|
.. math :: |
|
|
|
J(\tau) = \frac{g_2^3(\tau)}{g_2^3(\tau) - 27 g_3^2(\tau)} |
|
|
|
where `g_2` and `g_3` are the modular invariants of the Weierstrass |
|
elliptic function, |
|
|
|
.. math :: |
|
|
|
g_2(\tau) = 60 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-4} |
|
|
|
g_3(\tau) = 140 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-6}. |
|
|
|
An alternative, common notation is that of the j-function |
|
`j(\tau) = 1728 J(\tau)`. |
|
|
|
**Plots** |
|
|
|
.. literalinclude :: /plots/kleinj.py |
|
.. image :: /plots/kleinj.png |
|
.. literalinclude :: /plots/kleinj2.py |
|
.. image :: /plots/kleinj2.png |
|
|
|
**Examples** |
|
|
|
Verifying the functional equation `J(\tau) = J(\tau+1) = J(-\tau^{-1})`:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> tau = 0.625+0.75*j |
|
>>> tau = 0.625+0.75*j |
|
>>> kleinj(tau) |
|
(-0.1507492166511182267125242 + 0.07595948379084571927228948j) |
|
>>> kleinj(tau+1) |
|
(-0.1507492166511182267125242 + 0.07595948379084571927228948j) |
|
>>> kleinj(-1/tau) |
|
(-0.1507492166511182267125242 + 0.07595948379084571927228946j) |
|
|
|
The j-function has a famous Laurent series expansion in terms of the nome |
|
`\bar{q}`, `j(\tau) = \bar{q}^{-1} + 744 + 196884\bar{q} + \ldots`:: |
|
|
|
>>> mp.dps = 15 |
|
>>> taylor(lambda q: 1728*q*kleinj(qbar=q), 0, 5, singular=True) |
|
[1.0, 744.0, 196884.0, 21493760.0, 864299970.0, 20245856256.0] |
|
|
|
The j-function admits exact evaluation at special algebraic points |
|
related to the Heegner numbers 1, 2, 3, 7, 11, 19, 43, 67, 163:: |
|
|
|
>>> @extraprec(10) |
|
... def h(n): |
|
... v = (1+sqrt(n)*j) |
|
... if n > 2: |
|
... v *= 0.5 |
|
... return v |
|
... |
|
>>> mp.dps = 25 |
|
>>> for n in [1,2,3,7,11,19,43,67,163]: |
|
... n, chop(1728*kleinj(h(n))) |
|
... |
|
(1, 1728.0) |
|
(2, 8000.0) |
|
(3, 0.0) |
|
(7, -3375.0) |
|
(11, -32768.0) |
|
(19, -884736.0) |
|
(43, -884736000.0) |
|
(67, -147197952000.0) |
|
(163, -262537412640768000.0) |
|
|
|
Also at other special points, the j-function assumes explicit |
|
algebraic values, e.g.:: |
|
|
|
>>> chop(1728*kleinj(j*sqrt(5))) |
|
1264538.909475140509320227 |
|
>>> identify(cbrt(_)) # note: not simplified |
|
'((100+sqrt(13520))/2)' |
|
>>> (50+26*sqrt(5))**3 |
|
1264538.909475140509320227 |
|
|
|
""" |
|
q = ctx.qfrom(tau=tau, **kwargs) |
|
t2 = ctx.jtheta(2,0,q) |
|
t3 = ctx.jtheta(3,0,q) |
|
t4 = ctx.jtheta(4,0,q) |
|
P = (t2**8 + t3**8 + t4**8)**3 |
|
Q = 54*(t2*t3*t4)**8 |
|
return P/Q |
|
|
|
|
|
def RF_calc(ctx, x, y, z, r): |
|
if y == z: return RC_calc(ctx, x, y, r) |
|
if x == z: return RC_calc(ctx, y, x, r) |
|
if x == y: return RC_calc(ctx, z, x, r) |
|
if not (ctx.isnormal(x) and ctx.isnormal(y) and ctx.isnormal(z)): |
|
if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z): |
|
return x*y*z |
|
if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z): |
|
return ctx.zero |
|
xm,ym,zm = x,y,z |
|
A0 = Am = (x+y+z)/3 |
|
Q = ctx.root(3*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z)) |
|
g = ctx.mpf(0.25) |
|
pow4 = ctx.one |
|
while 1: |
|
xs = ctx.sqrt(xm) |
|
ys = ctx.sqrt(ym) |
|
zs = ctx.sqrt(zm) |
|
lm = xs*ys + xs*zs + ys*zs |
|
Am1 = (Am+lm)*g |
|
xm, ym, zm = (xm+lm)*g, (ym+lm)*g, (zm+lm)*g |
|
if pow4 * Q < abs(Am): |
|
break |
|
Am = Am1 |
|
pow4 *= g |
|
t = pow4/Am |
|
X = (A0-x)*t |
|
Y = (A0-y)*t |
|
Z = -X-Y |
|
E2 = X*Y-Z**2 |
|
E3 = X*Y*Z |
|
return ctx.power(Am,-0.5) * (9240-924*E2+385*E2**2+660*E3-630*E2*E3)/9240 |
|
|
|
def RC_calc(ctx, x, y, r, pv=True): |
|
if not (ctx.isnormal(x) and ctx.isnormal(y)): |
|
if ctx.isinf(x) or ctx.isinf(y): |
|
return 1/(x*y) |
|
if y == 0: |
|
return ctx.inf |
|
if x == 0: |
|
return ctx.pi / ctx.sqrt(y) / 2 |
|
raise ValueError |
|
|
|
if pv and ctx._im(y) == 0 and ctx._re(y) < 0: |
|
return ctx.sqrt(x/(x-y)) * RC_calc(ctx, x-y, -y, r) |
|
if x == y: |
|
return 1/ctx.sqrt(x) |
|
extraprec = 2*max(0,-ctx.mag(x-y)+ctx.mag(x)) |
|
ctx.prec += extraprec |
|
if ctx._is_real_type(x) and ctx._is_real_type(y): |
|
x = ctx._re(x) |
|
y = ctx._re(y) |
|
a = ctx.sqrt(x/y) |
|
if x < y: |
|
b = ctx.sqrt(y-x) |
|
v = ctx.acos(a)/b |
|
else: |
|
b = ctx.sqrt(x-y) |
|
v = ctx.acosh(a)/b |
|
else: |
|
sx = ctx.sqrt(x) |
|
sy = ctx.sqrt(y) |
|
v = ctx.acos(sx/sy)/(ctx.sqrt((1-x/y))*sy) |
|
ctx.prec -= extraprec |
|
return v |
|
|
|
def RJ_calc(ctx, x, y, z, p, r, integration): |
|
""" |
|
With integration == 0, computes RJ only using Carlson's algorithm |
|
(may be wrong for some values). |
|
With integration == 1, uses an initial integration to make sure |
|
Carlson's algorithm is correct. |
|
With integration == 2, uses only integration. |
|
""" |
|
if not (ctx.isnormal(x) and ctx.isnormal(y) and \ |
|
ctx.isnormal(z) and ctx.isnormal(p)): |
|
if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z) or ctx.isnan(p): |
|
return x*y*z |
|
if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z) or ctx.isinf(p): |
|
return ctx.zero |
|
if not p: |
|
return ctx.inf |
|
if (not x) + (not y) + (not z) > 1: |
|
return ctx.inf |
|
|
|
|
|
|
|
initial_integral = ctx.zero |
|
if integration >= 1: |
|
ok = (x.real >= 0 and y.real >= 0 and z.real >= 0 and p.real > 0) |
|
if not ok: |
|
if x == p or y == p or z == p: |
|
ok = True |
|
if not ok: |
|
if p.imag != 0 or p.real >= 0: |
|
if (x.imag == 0 and x.real >= 0 and ctx.conj(y) == z): |
|
ok = True |
|
if (y.imag == 0 and y.real >= 0 and ctx.conj(x) == z): |
|
ok = True |
|
if (z.imag == 0 and z.real >= 0 and ctx.conj(x) == y): |
|
ok = True |
|
if not ok or (integration == 2): |
|
N = ctx.ceil(-min(x.real, y.real, z.real, p.real)) + 1 |
|
|
|
if all((t.imag >= 0 or t.real > 0) for t in [x, y, z, p]): |
|
margin = ctx.j |
|
elif all((t.imag < 0 or t.real > 0) for t in [x, y, z, p]): |
|
margin = -ctx.j |
|
else: |
|
margin = 1 |
|
|
|
|
|
|
|
for t in [x, y, z, p]: |
|
if t.imag >= 0 or t.real > 0: |
|
continue |
|
margin = min(margin, abs(t.imag) * 0.5) |
|
margin *= ctx.j |
|
N += margin |
|
F = lambda t: 1/(ctx.sqrt(t+x)*ctx.sqrt(t+y)*ctx.sqrt(t+z)*(t+p)) |
|
if integration == 2: |
|
return 1.5 * ctx.quadsubdiv(F, [0, N, ctx.inf]) |
|
initial_integral = 1.5 * ctx.quadsubdiv(F, [0, N]) |
|
x += N; y += N; z += N; p += N |
|
xm,ym,zm,pm = x,y,z,p |
|
A0 = Am = (x + y + z + 2*p)/5 |
|
delta = (p-x)*(p-y)*(p-z) |
|
Q = ctx.root(0.25*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z),abs(A0-p)) |
|
g = ctx.mpf(0.25) |
|
pow4 = ctx.one |
|
S = 0 |
|
while 1: |
|
sx = ctx.sqrt(xm) |
|
sy = ctx.sqrt(ym) |
|
sz = ctx.sqrt(zm) |
|
sp = ctx.sqrt(pm) |
|
lm = sx*sy + sx*sz + sy*sz |
|
Am1 = (Am+lm)*g |
|
xm = (xm+lm)*g; ym = (ym+lm)*g; zm = (zm+lm)*g; pm = (pm+lm)*g |
|
dm = (sp+sx) * (sp+sy) * (sp+sz) |
|
em = delta * pow4**3 / dm**2 |
|
if pow4 * Q < abs(Am): |
|
break |
|
T = RC_calc(ctx, ctx.one, ctx.one+em, r) * pow4 / dm |
|
S += T |
|
pow4 *= g |
|
Am = Am1 |
|
t = pow4 / Am |
|
X = (A0-x)*t |
|
Y = (A0-y)*t |
|
Z = (A0-z)*t |
|
P = (-X-Y-Z)/2 |
|
E2 = X*Y + X*Z + Y*Z - 3*P**2 |
|
E3 = X*Y*Z + 2*E2*P + 4*P**3 |
|
E4 = (2*X*Y*Z + E2*P + 3*P**3)*P |
|
E5 = X*Y*Z*P**2 |
|
P = 24024 - 5148*E2 + 2457*E2**2 + 4004*E3 - 4158*E2*E3 - 3276*E4 + 2772*E5 |
|
Q = 24024 |
|
v1 = pow4 * ctx.power(Am, -1.5) * P/Q |
|
v2 = 6*S |
|
return initial_integral + v1 + v2 |
|
|
|
@defun |
|
def elliprf(ctx, x, y, z): |
|
r""" |
|
Evaluates the Carlson symmetric elliptic integral of the first kind |
|
|
|
.. math :: |
|
|
|
R_F(x,y,z) = \frac{1}{2} |
|
\int_0^{\infty} \frac{dt}{\sqrt{(t+x)(t+y)(t+z)}} |
|
|
|
which is defined for `x,y,z \notin (-\infty,0)`, and with |
|
at most one of `x,y,z` being zero. |
|
|
|
For real `x,y,z \ge 0`, the principal square root is taken in the integrand. |
|
For complex `x,y,z`, the principal square root is taken as `t \to \infty` |
|
and as `t \to 0` non-principal branches are chosen as necessary so as to |
|
make the integrand continuous. |
|
|
|
**Examples** |
|
|
|
Some basic values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> elliprf(0,1,1); pi/2 |
|
1.570796326794896619231322 |
|
1.570796326794896619231322 |
|
>>> elliprf(0,1,inf) |
|
0.0 |
|
>>> elliprf(1,1,1) |
|
1.0 |
|
>>> elliprf(2,2,2)**2 |
|
0.5 |
|
>>> elliprf(1,0,0); elliprf(0,0,1); elliprf(0,1,0); elliprf(0,0,0) |
|
+inf |
|
+inf |
|
+inf |
|
+inf |
|
|
|
Representing complete elliptic integrals in terms of `R_F`:: |
|
|
|
>>> m = mpf(0.75) |
|
>>> ellipk(m); elliprf(0,1-m,1) |
|
2.156515647499643235438675 |
|
2.156515647499643235438675 |
|
>>> ellipe(m); elliprf(0,1-m,1)-m*elliprd(0,1-m,1)/3 |
|
1.211056027568459524803563 |
|
1.211056027568459524803563 |
|
|
|
Some symmetries and argument transformations:: |
|
|
|
>>> x,y,z = 2,3,4 |
|
>>> elliprf(x,y,z); elliprf(y,x,z); elliprf(z,y,x) |
|
0.5840828416771517066928492 |
|
0.5840828416771517066928492 |
|
0.5840828416771517066928492 |
|
>>> k = mpf(100000) |
|
>>> elliprf(k*x,k*y,k*z); k**(-0.5) * elliprf(x,y,z) |
|
0.001847032121923321253219284 |
|
0.001847032121923321253219284 |
|
>>> l = sqrt(x*y) + sqrt(y*z) + sqrt(z*x) |
|
>>> elliprf(x,y,z); 2*elliprf(x+l,y+l,z+l) |
|
0.5840828416771517066928492 |
|
0.5840828416771517066928492 |
|
>>> elliprf((x+l)/4,(y+l)/4,(z+l)/4) |
|
0.5840828416771517066928492 |
|
|
|
Comparing with numerical integration:: |
|
|
|
>>> x,y,z = 2,3,4 |
|
>>> elliprf(x,y,z) |
|
0.5840828416771517066928492 |
|
>>> f = lambda t: 0.5*((t+x)*(t+y)*(t+z))**(-0.5) |
|
>>> q = extradps(25)(quad) |
|
>>> q(f, [0,inf]) |
|
0.5840828416771517066928492 |
|
|
|
With the following arguments, the square root in the integrand becomes |
|
discontinuous at `t = 1/2` if the principal branch is used. To obtain |
|
the right value, `-\sqrt{r}` must be taken instead of `\sqrt{r}` |
|
on `t \in (0, 1/2)`:: |
|
|
|
>>> x,y,z = j-1,j,0 |
|
>>> elliprf(x,y,z) |
|
(0.7961258658423391329305694 - 1.213856669836495986430094j) |
|
>>> -q(f, [0,0.5]) + q(f, [0.5,inf]) |
|
(0.7961258658423391329305694 - 1.213856669836495986430094j) |
|
|
|
The so-called *first lemniscate constant*, a transcendental number:: |
|
|
|
>>> elliprf(0,1,2) |
|
1.31102877714605990523242 |
|
>>> extradps(25)(quad)(lambda t: 1/sqrt(1-t**4), [0,1]) |
|
1.31102877714605990523242 |
|
>>> gamma('1/4')**2/(4*sqrt(2*pi)) |
|
1.31102877714605990523242 |
|
|
|
**References** |
|
|
|
1. [Carlson]_ |
|
2. [DLMF]_ Chapter 19. Elliptic Integrals |
|
|
|
""" |
|
x = ctx.convert(x) |
|
y = ctx.convert(y) |
|
z = ctx.convert(z) |
|
prec = ctx.prec |
|
try: |
|
ctx.prec += 20 |
|
tol = ctx.eps * 2**10 |
|
v = RF_calc(ctx, x, y, z, tol) |
|
finally: |
|
ctx.prec = prec |
|
return +v |
|
|
|
@defun |
|
def elliprc(ctx, x, y, pv=True): |
|
r""" |
|
Evaluates the degenerate Carlson symmetric elliptic integral |
|
of the first kind |
|
|
|
.. math :: |
|
|
|
R_C(x,y) = R_F(x,y,y) = |
|
\frac{1}{2} \int_0^{\infty} \frac{dt}{(t+y) \sqrt{(t+x)}}. |
|
|
|
If `y \in (-\infty,0)`, either a value defined by continuity, |
|
or with *pv=True* the Cauchy principal value, can be computed. |
|
|
|
If `x \ge 0, y > 0`, the value can be expressed in terms of |
|
elementary functions as |
|
|
|
.. math :: |
|
|
|
R_C(x,y) = |
|
\begin{cases} |
|
\dfrac{1}{\sqrt{y-x}} |
|
\cos^{-1}\left(\sqrt{\dfrac{x}{y}}\right), & x < y \\ |
|
\dfrac{1}{\sqrt{y}}, & x = y \\ |
|
\dfrac{1}{\sqrt{x-y}} |
|
\cosh^{-1}\left(\sqrt{\dfrac{x}{y}}\right), & x > y \\ |
|
\end{cases}. |
|
|
|
**Examples** |
|
|
|
Some special values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> elliprc(1,2)*4; elliprc(0,1)*2; +pi |
|
3.141592653589793238462643 |
|
3.141592653589793238462643 |
|
3.141592653589793238462643 |
|
>>> elliprc(1,0) |
|
+inf |
|
>>> elliprc(5,5)**2 |
|
0.2 |
|
>>> elliprc(1,inf); elliprc(inf,1); elliprc(inf,inf) |
|
0.0 |
|
0.0 |
|
0.0 |
|
|
|
Comparing with the elementary closed-form solution:: |
|
|
|
>>> elliprc('1/3', '1/5'); sqrt(7.5)*acosh(sqrt('5/3')) |
|
2.041630778983498390751238 |
|
2.041630778983498390751238 |
|
>>> elliprc('1/5', '1/3'); sqrt(7.5)*acos(sqrt('3/5')) |
|
1.875180765206547065111085 |
|
1.875180765206547065111085 |
|
|
|
Comparing with numerical integration:: |
|
|
|
>>> q = extradps(25)(quad) |
|
>>> elliprc(2, -3, pv=True) |
|
0.3333969101113672670749334 |
|
>>> elliprc(2, -3, pv=False) |
|
(0.3333969101113672670749334 + 0.7024814731040726393156375j) |
|
>>> 0.5*q(lambda t: 1/(sqrt(t+2)*(t-3)), [0,3-j,6,inf]) |
|
(0.3333969101113672670749334 + 0.7024814731040726393156375j) |
|
|
|
""" |
|
x = ctx.convert(x) |
|
y = ctx.convert(y) |
|
prec = ctx.prec |
|
try: |
|
ctx.prec += 20 |
|
tol = ctx.eps * 2**10 |
|
v = RC_calc(ctx, x, y, tol, pv) |
|
finally: |
|
ctx.prec = prec |
|
return +v |
|
|
|
@defun |
|
def elliprj(ctx, x, y, z, p, integration=1): |
|
r""" |
|
Evaluates the Carlson symmetric elliptic integral of the third kind |
|
|
|
.. math :: |
|
|
|
R_J(x,y,z,p) = \frac{3}{2} |
|
\int_0^{\infty} \frac{dt}{(t+p)\sqrt{(t+x)(t+y)(t+z)}}. |
|
|
|
Like :func:`~mpmath.elliprf`, the branch of the square root in the integrand |
|
is defined so as to be continuous along the path of integration for |
|
complex values of the arguments. |
|
|
|
**Examples** |
|
|
|
Some values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> elliprj(1,1,1,1) |
|
1.0 |
|
>>> elliprj(2,2,2,2); 1/(2*sqrt(2)) |
|
0.3535533905932737622004222 |
|
0.3535533905932737622004222 |
|
>>> elliprj(0,1,2,2) |
|
1.067937989667395702268688 |
|
>>> 3*(2*gamma('5/4')**2-pi**2/gamma('1/4')**2)/(sqrt(2*pi)) |
|
1.067937989667395702268688 |
|
>>> elliprj(0,1,1,2); 3*pi*(2-sqrt(2))/4 |
|
1.380226776765915172432054 |
|
1.380226776765915172432054 |
|
>>> elliprj(1,3,2,0); elliprj(0,1,1,0); elliprj(0,0,0,0) |
|
+inf |
|
+inf |
|
+inf |
|
>>> elliprj(1,inf,1,0); elliprj(1,1,1,inf) |
|
0.0 |
|
0.0 |
|
>>> chop(elliprj(1+j, 1-j, 1, 1)) |
|
0.8505007163686739432927844 |
|
|
|
Scale transformation:: |
|
|
|
>>> x,y,z,p = 2,3,4,5 |
|
>>> k = mpf(100000) |
|
>>> elliprj(k*x,k*y,k*z,k*p); k**(-1.5)*elliprj(x,y,z,p) |
|
4.521291677592745527851168e-9 |
|
4.521291677592745527851168e-9 |
|
|
|
Comparing with numerical integration:: |
|
|
|
>>> elliprj(1,2,3,4) |
|
0.2398480997495677621758617 |
|
>>> f = lambda t: 1/((t+4)*sqrt((t+1)*(t+2)*(t+3))) |
|
>>> 1.5*quad(f, [0,inf]) |
|
0.2398480997495677621758617 |
|
>>> elliprj(1,2+1j,3,4-2j) |
|
(0.216888906014633498739952 + 0.04081912627366673332369512j) |
|
>>> f = lambda t: 1/((t+4-2j)*sqrt((t+1)*(t+2+1j)*(t+3))) |
|
>>> 1.5*quad(f, [0,inf]) |
|
(0.216888906014633498739952 + 0.04081912627366673332369511j) |
|
|
|
""" |
|
x = ctx.convert(x) |
|
y = ctx.convert(y) |
|
z = ctx.convert(z) |
|
p = ctx.convert(p) |
|
prec = ctx.prec |
|
try: |
|
ctx.prec += 20 |
|
tol = ctx.eps * 2**10 |
|
v = RJ_calc(ctx, x, y, z, p, tol, integration) |
|
finally: |
|
ctx.prec = prec |
|
return +v |
|
|
|
@defun |
|
def elliprd(ctx, x, y, z): |
|
r""" |
|
Evaluates the degenerate Carlson symmetric elliptic integral |
|
of the third kind or Carlson elliptic integral of the |
|
second kind `R_D(x,y,z) = R_J(x,y,z,z)`. |
|
|
|
See :func:`~mpmath.elliprj` for additional information. |
|
|
|
**Examples** |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> elliprd(1,2,3) |
|
0.2904602810289906442326534 |
|
>>> elliprj(1,2,3,3) |
|
0.2904602810289906442326534 |
|
|
|
The so-called *second lemniscate constant*, a transcendental number:: |
|
|
|
>>> elliprd(0,2,1)/3 |
|
0.5990701173677961037199612 |
|
>>> extradps(25)(quad)(lambda t: t**2/sqrt(1-t**4), [0,1]) |
|
0.5990701173677961037199612 |
|
>>> gamma('3/4')**2/sqrt(2*pi) |
|
0.5990701173677961037199612 |
|
|
|
""" |
|
return ctx.elliprj(x,y,z,z) |
|
|
|
@defun |
|
def elliprg(ctx, x, y, z): |
|
r""" |
|
Evaluates the Carlson completely symmetric elliptic integral |
|
of the second kind |
|
|
|
.. math :: |
|
|
|
R_G(x,y,z) = \frac{1}{4} \int_0^{\infty} |
|
\frac{t}{\sqrt{(t+x)(t+y)(t+z)}} |
|
\left( \frac{x}{t+x} + \frac{y}{t+y} + \frac{z}{t+z}\right) dt. |
|
|
|
**Examples** |
|
|
|
Evaluation for real and complex arguments:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> elliprg(0,1,1)*4; +pi |
|
3.141592653589793238462643 |
|
3.141592653589793238462643 |
|
>>> elliprg(0,0.5,1) |
|
0.6753219405238377512600874 |
|
>>> chop(elliprg(1+j, 1-j, 2)) |
|
1.172431327676416604532822 |
|
|
|
A double integral that can be evaluated in terms of `R_G`:: |
|
|
|
>>> x,y,z = 2,3,4 |
|
>>> def f(t,u): |
|
... st = fp.sin(t); ct = fp.cos(t) |
|
... su = fp.sin(u); cu = fp.cos(u) |
|
... return (x*(st*cu)**2 + y*(st*su)**2 + z*ct**2)**0.5 * st |
|
... |
|
>>> nprint(mpf(fp.quad(f, [0,fp.pi], [0,2*fp.pi])/(4*fp.pi)), 13) |
|
1.725503028069 |
|
>>> nprint(elliprg(x,y,z), 13) |
|
1.725503028069 |
|
|
|
""" |
|
x = ctx.convert(x) |
|
y = ctx.convert(y) |
|
z = ctx.convert(z) |
|
zeros = (not x) + (not y) + (not z) |
|
if zeros == 3: |
|
return (x+y+z)*0 |
|
if zeros == 2: |
|
if x: return 0.5*ctx.sqrt(x) |
|
if y: return 0.5*ctx.sqrt(y) |
|
return 0.5*ctx.sqrt(z) |
|
if zeros == 1: |
|
if not z: |
|
x, z = z, x |
|
def terms(): |
|
T1 = 0.5*z*ctx.elliprf(x,y,z) |
|
T2 = -0.5*(x-z)*(y-z)*ctx.elliprd(x,y,z)/3 |
|
T3 = 0.5*ctx.sqrt(x)*ctx.sqrt(y)/ctx.sqrt(z) |
|
return T1,T2,T3 |
|
return ctx.sum_accurately(terms) |
|
|
|
|
|
@defun_wrapped |
|
def ellipf(ctx, phi, m): |
|
r""" |
|
Evaluates the Legendre incomplete elliptic integral of the first kind |
|
|
|
.. math :: |
|
|
|
F(\phi,m) = \int_0^{\phi} \frac{dt}{\sqrt{1-m \sin^2 t}} |
|
|
|
or equivalently |
|
|
|
.. math :: |
|
|
|
F(\phi,m) = \int_0^{\sin \phi} |
|
\frac{dt}{\left(\sqrt{1-t^2}\right)\left(\sqrt{1-mt^2}\right)}. |
|
|
|
The function reduces to a complete elliptic integral of the first kind |
|
(see :func:`~mpmath.ellipk`) when `\phi = \frac{\pi}{2}`; that is, |
|
|
|
.. math :: |
|
|
|
F\left(\frac{\pi}{2}, m\right) = K(m). |
|
|
|
In the defining integral, it is assumed that the principal branch |
|
of the square root is taken and that the path of integration avoids |
|
crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`, |
|
the function extends quasi-periodically as |
|
|
|
.. math :: |
|
|
|
F(\phi + n \pi, m) = 2 n K(m) + F(\phi,m), n \in \mathbb{Z}. |
|
|
|
**Plots** |
|
|
|
.. literalinclude :: /plots/ellipf.py |
|
.. image :: /plots/ellipf.png |
|
|
|
**Examples** |
|
|
|
Basic values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> ellipf(0,1) |
|
0.0 |
|
>>> ellipf(0,0) |
|
0.0 |
|
>>> ellipf(1,0); ellipf(2+3j,0) |
|
1.0 |
|
(2.0 + 3.0j) |
|
>>> ellipf(1,1); log(sec(1)+tan(1)) |
|
1.226191170883517070813061 |
|
1.226191170883517070813061 |
|
>>> ellipf(pi/2, -0.5); ellipk(-0.5) |
|
1.415737208425956198892166 |
|
1.415737208425956198892166 |
|
>>> ellipf(pi/2+eps, 1); ellipf(-pi/2-eps, 1) |
|
+inf |
|
+inf |
|
>>> ellipf(1.5, 1) |
|
3.340677542798311003320813 |
|
|
|
Comparing with numerical integration:: |
|
|
|
>>> z,m = 0.5, 1.25 |
|
>>> ellipf(z,m) |
|
0.5287219202206327872978255 |
|
>>> quad(lambda t: (1-m*sin(t)**2)**(-0.5), [0,z]) |
|
0.5287219202206327872978255 |
|
|
|
The arguments may be complex numbers:: |
|
|
|
>>> ellipf(3j, 0.5) |
|
(0.0 + 1.713602407841590234804143j) |
|
>>> ellipf(3+4j, 5-6j) |
|
(1.269131241950351323305741 - 0.3561052815014558335412538j) |
|
>>> z,m = 2+3j, 1.25 |
|
>>> k = 1011 |
|
>>> ellipf(z+pi*k,m); ellipf(z,m) + 2*k*ellipk(m) |
|
(4086.184383622179764082821 - 3003.003538923749396546871j) |
|
(4086.184383622179764082821 - 3003.003538923749396546871j) |
|
|
|
For `|\Re(z)| < \pi/2`, the function can be expressed as a |
|
hypergeometric series of two variables |
|
(see :func:`~mpmath.appellf1`):: |
|
|
|
>>> z,m = 0.5, 0.25 |
|
>>> ellipf(z,m) |
|
0.5050887275786480788831083 |
|
>>> sin(z)*appellf1(0.5,0.5,0.5,1.5,sin(z)**2,m*sin(z)**2) |
|
0.5050887275786480788831083 |
|
|
|
""" |
|
z = phi |
|
if not (ctx.isnormal(z) and ctx.isnormal(m)): |
|
if m == 0: |
|
return z + m |
|
if z == 0: |
|
return z * m |
|
if m == ctx.inf or m == ctx.ninf: return z/m |
|
raise ValueError |
|
x = z.real |
|
ctx.prec += max(0, ctx.mag(x)) |
|
pi = +ctx.pi |
|
away = abs(x) > pi/2 |
|
if m == 1: |
|
if away: |
|
return ctx.inf |
|
if away: |
|
d = ctx.nint(x/pi) |
|
z = z-pi*d |
|
P = 2*d*ctx.ellipk(m) |
|
else: |
|
P = 0 |
|
c, s = ctx.cos_sin(z) |
|
return s * ctx.elliprf(c**2, 1-m*s**2, 1) + P |
|
|
|
@defun_wrapped |
|
def ellipe(ctx, *args): |
|
r""" |
|
Called with a single argument `m`, evaluates the Legendre complete |
|
elliptic integral of the second kind, `E(m)`, defined by |
|
|
|
.. math :: E(m) = \int_0^{\pi/2} \sqrt{1-m \sin^2 t} \, dt \,=\, |
|
\frac{\pi}{2} |
|
\,_2F_1\left(\frac{1}{2}, -\frac{1}{2}, 1, m\right). |
|
|
|
Called with two arguments `\phi, m`, evaluates the incomplete elliptic |
|
integral of the second kind |
|
|
|
.. math :: |
|
|
|
E(\phi,m) = \int_0^{\phi} \sqrt{1-m \sin^2 t} \, dt = |
|
\int_0^{\sin z} |
|
\frac{\sqrt{1-mt^2}}{\sqrt{1-t^2}} \, dt. |
|
|
|
The incomplete integral reduces to a complete integral when |
|
`\phi = \frac{\pi}{2}`; that is, |
|
|
|
.. math :: |
|
|
|
E\left(\frac{\pi}{2}, m\right) = E(m). |
|
|
|
In the defining integral, it is assumed that the principal branch |
|
of the square root is taken and that the path of integration avoids |
|
crossing any branch cuts. Outside `-\pi/2 \le \Re(z) \le \pi/2`, |
|
the function extends quasi-periodically as |
|
|
|
.. math :: |
|
|
|
E(\phi + n \pi, m) = 2 n E(m) + E(\phi,m), n \in \mathbb{Z}. |
|
|
|
**Plots** |
|
|
|
.. literalinclude :: /plots/ellipe.py |
|
.. image :: /plots/ellipe.png |
|
|
|
**Examples for the complete integral** |
|
|
|
Basic values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> ellipe(0) |
|
1.570796326794896619231322 |
|
>>> ellipe(1) |
|
1.0 |
|
>>> ellipe(-1) |
|
1.910098894513856008952381 |
|
>>> ellipe(2) |
|
(0.5990701173677961037199612 + 0.5990701173677961037199612j) |
|
>>> ellipe(inf) |
|
(0.0 + +infj) |
|
>>> ellipe(-inf) |
|
+inf |
|
|
|
Verifying the defining integral and hypergeometric |
|
representation:: |
|
|
|
>>> ellipe(0.5) |
|
1.350643881047675502520175 |
|
>>> quad(lambda t: sqrt(1-0.5*sin(t)**2), [0, pi/2]) |
|
1.350643881047675502520175 |
|
>>> pi/2*hyp2f1(0.5,-0.5,1,0.5) |
|
1.350643881047675502520175 |
|
|
|
Evaluation is supported for arbitrary complex `m`:: |
|
|
|
>>> ellipe(0.5+0.25j) |
|
(1.360868682163129682716687 - 0.1238733442561786843557315j) |
|
>>> ellipe(3+4j) |
|
(1.499553520933346954333612 - 1.577879007912758274533309j) |
|
|
|
A definite integral:: |
|
|
|
>>> quad(ellipe, [0,1]) |
|
1.333333333333333333333333 |
|
|
|
**Examples for the incomplete integral** |
|
|
|
Basic values and limits:: |
|
|
|
>>> ellipe(0,1) |
|
0.0 |
|
>>> ellipe(0,0) |
|
0.0 |
|
>>> ellipe(1,0) |
|
1.0 |
|
>>> ellipe(2+3j,0) |
|
(2.0 + 3.0j) |
|
>>> ellipe(1,1); sin(1) |
|
0.8414709848078965066525023 |
|
0.8414709848078965066525023 |
|
>>> ellipe(pi/2, -0.5); ellipe(-0.5) |
|
1.751771275694817862026502 |
|
1.751771275694817862026502 |
|
>>> ellipe(pi/2, 1); ellipe(-pi/2, 1) |
|
1.0 |
|
-1.0 |
|
>>> ellipe(1.5, 1) |
|
0.9974949866040544309417234 |
|
|
|
Comparing with numerical integration:: |
|
|
|
>>> z,m = 0.5, 1.25 |
|
>>> ellipe(z,m) |
|
0.4740152182652628394264449 |
|
>>> quad(lambda t: sqrt(1-m*sin(t)**2), [0,z]) |
|
0.4740152182652628394264449 |
|
|
|
The arguments may be complex numbers:: |
|
|
|
>>> ellipe(3j, 0.5) |
|
(0.0 + 7.551991234890371873502105j) |
|
>>> ellipe(3+4j, 5-6j) |
|
(24.15299022574220502424466 + 75.2503670480325997418156j) |
|
>>> k = 35 |
|
>>> z,m = 2+3j, 1.25 |
|
>>> ellipe(z+pi*k,m); ellipe(z,m) + 2*k*ellipe(m) |
|
(48.30138799412005235090766 + 17.47255216721987688224357j) |
|
(48.30138799412005235090766 + 17.47255216721987688224357j) |
|
|
|
For `|\Re(z)| < \pi/2`, the function can be expressed as a |
|
hypergeometric series of two variables |
|
(see :func:`~mpmath.appellf1`):: |
|
|
|
>>> z,m = 0.5, 0.25 |
|
>>> ellipe(z,m) |
|
0.4950017030164151928870375 |
|
>>> sin(z)*appellf1(0.5,0.5,-0.5,1.5,sin(z)**2,m*sin(z)**2) |
|
0.4950017030164151928870376 |
|
|
|
""" |
|
if len(args) == 1: |
|
return ctx._ellipe(args[0]) |
|
else: |
|
phi, m = args |
|
z = phi |
|
if not (ctx.isnormal(z) and ctx.isnormal(m)): |
|
if m == 0: |
|
return z + m |
|
if z == 0: |
|
return z * m |
|
if m == ctx.inf or m == ctx.ninf: |
|
return ctx.inf |
|
raise ValueError |
|
x = z.real |
|
ctx.prec += max(0, ctx.mag(x)) |
|
pi = +ctx.pi |
|
away = abs(x) > pi/2 |
|
if away: |
|
d = ctx.nint(x/pi) |
|
z = z-pi*d |
|
P = 2*d*ctx.ellipe(m) |
|
else: |
|
P = 0 |
|
def terms(): |
|
c, s = ctx.cos_sin(z) |
|
x = c**2 |
|
y = 1-m*s**2 |
|
RF = ctx.elliprf(x, y, 1) |
|
RD = ctx.elliprd(x, y, 1) |
|
return s*RF, -m*s**3*RD/3 |
|
return ctx.sum_accurately(terms) + P |
|
|
|
@defun_wrapped |
|
def ellippi(ctx, *args): |
|
r""" |
|
Called with three arguments `n, \phi, m`, evaluates the Legendre |
|
incomplete elliptic integral of the third kind |
|
|
|
.. math :: |
|
|
|
\Pi(n; \phi, m) = \int_0^{\phi} |
|
\frac{dt}{(1-n \sin^2 t) \sqrt{1-m \sin^2 t}} = |
|
\int_0^{\sin \phi} |
|
\frac{dt}{(1-nt^2) \sqrt{1-t^2} \sqrt{1-mt^2}}. |
|
|
|
Called with two arguments `n, m`, evaluates the complete |
|
elliptic integral of the third kind |
|
`\Pi(n,m) = \Pi(n; \frac{\pi}{2},m)`. |
|
|
|
In the defining integral, it is assumed that the principal branch |
|
of the square root is taken and that the path of integration avoids |
|
crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`, |
|
the function extends quasi-periodically as |
|
|
|
.. math :: |
|
|
|
\Pi(n,\phi+k\pi,m) = 2k\Pi(n,m) + \Pi(n,\phi,m), k \in \mathbb{Z}. |
|
|
|
**Plots** |
|
|
|
.. literalinclude :: /plots/ellippi.py |
|
.. image :: /plots/ellippi.png |
|
|
|
**Examples for the complete integral** |
|
|
|
Some basic values and limits:: |
|
|
|
>>> from mpmath import * |
|
>>> mp.dps = 25; mp.pretty = True |
|
>>> ellippi(0,-5); ellipk(-5) |
|
0.9555039270640439337379334 |
|
0.9555039270640439337379334 |
|
>>> ellippi(inf,2) |
|
0.0 |
|
>>> ellippi(2,inf) |
|
0.0 |
|
>>> abs(ellippi(1,5)) |
|
+inf |
|
>>> abs(ellippi(0.25,1)) |
|
+inf |
|
|
|
Evaluation in terms of simpler functions:: |
|
|
|
>>> ellippi(0.25,0.25); ellipe(0.25)/(1-0.25) |
|
1.956616279119236207279727 |
|
1.956616279119236207279727 |
|
>>> ellippi(3,0); pi/(2*sqrt(-2)) |
|
(0.0 - 1.11072073453959156175397j) |
|
(0.0 - 1.11072073453959156175397j) |
|
>>> ellippi(-3,0); pi/(2*sqrt(4)) |
|
0.7853981633974483096156609 |
|
0.7853981633974483096156609 |
|
|
|
**Examples for the incomplete integral** |
|
|
|
Basic values and limits:: |
|
|
|
>>> ellippi(0.25,-0.5); ellippi(0.25,pi/2,-0.5) |
|
1.622944760954741603710555 |
|
1.622944760954741603710555 |
|
>>> ellippi(1,0,1) |
|
0.0 |
|
>>> ellippi(inf,0,1) |
|
0.0 |
|
>>> ellippi(0,0.25,0.5); ellipf(0.25,0.5) |
|
0.2513040086544925794134591 |
|
0.2513040086544925794134591 |
|
>>> ellippi(1,1,1); (log(sec(1)+tan(1))+sec(1)*tan(1))/2 |
|
2.054332933256248668692452 |
|
2.054332933256248668692452 |
|
>>> ellippi(0.25, 53*pi/2, 0.75); 53*ellippi(0.25,0.75) |
|
135.240868757890840755058 |
|
135.240868757890840755058 |
|
>>> ellippi(0.5,pi/4,0.5); 2*ellipe(pi/4,0.5)-1/sqrt(3) |
|
0.9190227391656969903987269 |
|
0.9190227391656969903987269 |
|
|
|
Complex arguments are supported:: |
|
|
|
>>> ellippi(0.5, 5+6j-2*pi, -7-8j) |
|
(-0.3612856620076747660410167 + 0.5217735339984807829755815j) |
|
|
|
Some degenerate cases:: |
|
|
|
>>> ellippi(1,1) |
|
+inf |
|
>>> ellippi(1,0) |
|
+inf |
|
>>> ellippi(1,2,0) |
|
+inf |
|
>>> ellippi(1,2,1) |
|
+inf |
|
>>> ellippi(1,0,1) |
|
0.0 |
|
|
|
""" |
|
if len(args) == 2: |
|
n, m = args |
|
complete = True |
|
z = phi = ctx.pi/2 |
|
else: |
|
n, phi, m = args |
|
complete = False |
|
z = phi |
|
if not (ctx.isnormal(n) and ctx.isnormal(z) and ctx.isnormal(m)): |
|
if ctx.isnan(n) or ctx.isnan(z) or ctx.isnan(m): |
|
raise ValueError |
|
if complete: |
|
if m == 0: |
|
if n == 1: |
|
return ctx.inf |
|
return ctx.pi/(2*ctx.sqrt(1-n)) |
|
if n == 0: return ctx.ellipk(m) |
|
if ctx.isinf(n) or ctx.isinf(m): return ctx.zero |
|
else: |
|
if z == 0: return z |
|
if ctx.isinf(n): return ctx.zero |
|
if ctx.isinf(m): return ctx.zero |
|
if ctx.isinf(n) or ctx.isinf(z) or ctx.isinf(m): |
|
raise ValueError |
|
if complete: |
|
if m == 1: |
|
if n == 1: |
|
return ctx.inf |
|
return -ctx.inf/ctx.sign(n-1) |
|
away = False |
|
else: |
|
x = z.real |
|
ctx.prec += max(0, ctx.mag(x)) |
|
pi = +ctx.pi |
|
away = abs(x) > pi/2 |
|
if away: |
|
d = ctx.nint(x/pi) |
|
z = z-pi*d |
|
P = 2*d*ctx.ellippi(n,m) |
|
if ctx.isinf(P): |
|
return ctx.inf |
|
else: |
|
P = 0 |
|
def terms(): |
|
if complete: |
|
c, s = ctx.zero, ctx.one |
|
else: |
|
c, s = ctx.cos_sin(z) |
|
x = c**2 |
|
y = 1-m*s**2 |
|
RF = ctx.elliprf(x, y, 1) |
|
RJ = ctx.elliprj(x, y, 1, 1-n*s**2) |
|
return s*RF, n*s**3*RJ/3 |
|
return ctx.sum_accurately(terms) + P |
|
|
