def _eval_evalf(self, prec):
from mpmath import mp, workprec
from diofant import Expr
z = self.args[0]._to_mpmath(prec)
with workprec(prec):
res = mp.airybi(z, derivative=1)
return Expr._from_mpmath(res, prec)
def _eval_evalf(self, prec):
from mpmath import mp, workprec
from diofant import Expr
a = self.args[0]._to_mpmath(prec)
z = self.args[1]._to_mpmath(prec)
with workprec(prec):
res = mp.gammainc(a, z, mp.inf)
return Expr._from_mpmath(res, prec)
def _eval_evalf(self, prec):
m = self.args[0]
if m.is_Integer and m.is_nonnegative:
from mpmath import mp
from diofant import Expr
m = m._to_mpmath(prec)
with workprec(prec):
res = mp.eulernum(m)
return Expr._from_mpmath(res, prec)
def _eval_evalf(self, prec):
# The default code is insufficient for polar arguments.
# mpmath provides an optional argument "r", which evaluates
# G(z**(1/r)). I am not sure what its intended use is, but we hijack it
# here in the following way: to evaluate at a number z of |argument|
# less than (say) n*pi, we put r=1/n, compute z' = root(z, n)
# (carefully so as not to loose the branch information), and evaluate
# G(z'**(1/r)) = G(z'**n) = G(z).
from diofant.functions import exp_polar, ceiling
from diofant import Expr
import mpmath
z = self.argument
znum = self.argument._eval_evalf(prec)
if znum.has(exp_polar):
znum, branch = znum.as_coeff_mul(exp_polar)
if len(branch) != 1:
return
branch = branch[0].args[0] / I
else:
branch = Integer(0)
n = ceiling(abs(branch / S.Pi)) + 1
znum = znum**(Integer(1) / n) * exp(I * branch / n)
# Convert all args to mpf or mpc
try:
[z, r, ap, bq] = [
arg._to_mpmath(prec)
for arg in [znum, 1 / n, self.args[0], self.args[1]]
]
except ValueError:
return
with mpmath.workprec(prec):
v = mpmath.meijerg(ap, bq, z, r)
return Expr._from_mpmath(v, prec)
def test_sympyissue_5486_bug():
assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
pytest.raises(TypeError, lambda: Expr._from_mpmath(I, 15))
def test_issue_5486_bug():
from diofant import I, Expr
assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
pytest.raises(TypeError, lambda: Expr._from_mpmath(I, 15))
def test_sympyissue_5486_bug():
assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
pytest.raises(TypeError, lambda: Expr._from_mpmath(I, 15))
def test_from_mpmath():
# issue sympy/sympy#5486
pytest.raises(TypeError, lambda: Expr._from_mpmath(I, 15))
def test_sympyissue_5486():
assert not cos(sqrt(0.5 + I)).evalf(strict=False).is_Function
assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
def test_sympyissue_5486_bug():
assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
def jn_zeros(n, k, method="diofant", dps=15):
"""
Zeros of the spherical Bessel function of the first kind.
This returns an array of zeros of jn up to the k-th zero.
* method = "diofant": uses mpmath's function ``besseljzero``
* method = "scipy": uses the
`SciPy's sph_jn <http://docs.scipy.org/doc/scipy/reference/generated/scipy.special.jn_zeros.html>`_
and
`newton <http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html>`_
to find all
roots, which is faster than computing the zeros using a general
numerical solver, but it requires SciPy and only works with low
precision floating point numbers. [The function used with
method="diofant" is a recent addition to mpmath, before that a general
solver was used.]
Examples
========
>>> from diofant import jn_zeros
>>> jn_zeros(2, 4, dps=5)
[5.7635, 9.095, 12.323, 15.515]
See Also
========
jn, yn, besselj, besselk, bessely
"""
from math import pi
if method == "diofant":
from mpmath import besseljzero
from mpmath.libmp.libmpf import dps_to_prec
from diofant import Expr
prec = dps_to_prec(dps)
return [
Expr._from_mpmath(
besseljzero(sympify(n + 0.5)._to_mpmath(prec), int(l)), prec)
for l in range(1, k + 1)
]
elif method == "scipy":
from scipy.special import sph_jn
from scipy.optimize import newton
def f(x):
return sph_jn(n, x)[0][-1]
else:
raise NotImplementedError("Unknown method.")
def solver(f, x):
if method == "scipy":
root = newton(f, x)
else:
raise NotImplementedError("Unknown method.")
return root
# we need to approximate the position of the first root:
root = n + pi
# determine the first root exactly:
root = solver(f, root)
roots = [root]
for i in range(k - 1):
# estimate the position of the next root using the last root + pi:
root = solver(f, root + pi)
roots.append(root)
return roots