def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_J(0.0, 1.0)
0.765197686557967
sage: bessel_J(0, 1).n(digits=20)
0.76519768655796655145
sage: bessel_J(0.5, 1.5)
0.649838074753747
Check for correct rounding (:trac:`17122`)::
sage: R = RealField(113)
sage: a = R("8.935761195587725798762818805462843676e-01")
sage: aa = RealField(200)(a)
sage: for n in [-10..10]:
....: b = bessel_J(R(n), a)
....: bb = R(bessel_J(n, aa))
....: if b != bb:
....: print n, b-bb
"""
if parent is not None:
x = parent(x)
try:
return x.jn(Integer(n))
except Exception:
pass
n, x = get_coercion_model().canonical_coercion(n, x)
import mpmath
return mpmath_utils.call(mpmath.besselj, n, x, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_Y(0.5, 1.5)
-0.0460831658930974
sage: bessel_Y(1.0+2*I, 3.0+4*I)
0.699410324467538 + 0.228917940896421*I
sage: bessel_Y(0, 1).n(256)
0.08825696421567695798292676602351516282781752309067554671104384761199978932351
Check for correct rounding (:trac:`17122`)::
sage: R = RealField(113)
sage: a = R("8.935761195587725798762818805462843676e-01")
sage: aa = RealField(200)(a)
sage: for n in [-10..10]:
....: b = bessel_Y(R(n), a)
....: bb = R(bessel_Y(n, aa))
....: if b != bb:
....: print n, b-bb
"""
if parent is not None:
x = parent(x)
try:
return x.yn(Integer(n))
except Exception:
pass
n, x = get_coercion_model().canonical_coercion(n, x)
import mpmath
return mpmath_utils.call(mpmath.bessely, n, x, parent=parent)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: erf(2).n()
0.995322265018953
sage: erf(2).n(200)
0.99532226501895273416206925636725292861089179704006007673835
sage: erf(pi - 1/2*I).n(100)
1.0000111669099367825726058952 + 1.6332655417638522934072124547e-6*I
TESTS:
Check that PARI/GP through the GP interface gives the same answer::
sage: gp.set_real_precision(59) # random
38
sage: print(gp.eval("1 - erfc(1)")); print(erf(1).n(200));
0.84270079294971486934122063508260925929606699796630290845994
0.84270079294971486934122063508260925929606699796630290845994
Check that for an imaginary input, the output is also imaginary, see
:trac:`13193`::
sage: erf(3.0*I)
1629.99462260157*I
sage: erf(33.0*I)
1.51286977510409e471*I
"""
R = parent or s_parent(x)
import mpmath
return mpmath_utils.call(mpmath.erf, x, parent=R)
def __call__(self, x, prec=None, coerce=True, hold=False):
"""
Note that the ``prec`` argument is deprecated. The precision for
the result is deduced from the precision of the input. Convert
the input to a higher precision explicitly if a result with higher
precision is desired.
EXAMPLES::
sage: t = Ei(RealField(100)(2.5)); t
7.0737658945786007119235519625
sage: t.prec()
100
sage: Ei(1.1, prec=300)
doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.
2.16737827956340306615064476647912607220394065907142504328679588538509331805598360907980986
"""
if prec is not None:
from sage.misc.misc import deprecation
deprecation(
"The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead."
)
import mpmath
return mpmath_utils.call(mpmath.ei, x, prec=prec)
return BuiltinFunction.__call__(self, x, coerce=coerce, hold=hold)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_Y(0.5, 1.5)
-0.0460831658930974
sage: bessel_Y(1.0+2*I, 3.0+4*I)
0.699410324467538 + 0.228917940896421*I
sage: bessel_Y(0, 1).n(256)
0.08825696421567695798292676602351516282781752309067554671104384761199978932351
Check for correct rounding (:trac:`17122`)::
sage: R = RealField(113)
sage: a = R("8.935761195587725798762818805462843676e-01")
sage: aa = RealField(200)(a)
sage: for n in [-10..10]:
....: b = bessel_Y(R(n), a)
....: bb = R(bessel_Y(n, aa))
....: if b != bb:
....: print n, b-bb
"""
if parent is not None:
x = parent(x)
try:
return x.yn(Integer(n))
except Exception:
pass
n, x = get_coercion_model().canonical_coercion(n, x)
import mpmath
return mpmath_utils.call(mpmath.bessely, n, x, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_J(0.0, 1.0)
0.765197686557967
sage: bessel_J(0, 1).n(digits=20)
0.76519768655796655145
sage: bessel_J(0.5, 1.5)
0.649838074753747
Check for correct rounding (:trac:`17122`)::
sage: R = RealField(113)
sage: a = R("8.935761195587725798762818805462843676e-01")
sage: aa = RealField(200)(a)
sage: for n in [-10..10]:
....: b = bessel_J(R(n), a)
....: bb = R(bessel_J(n, aa))
....: if b != bb:
....: print n, b-bb
"""
if parent is not None:
x = parent(x)
try:
return x.jn(Integer(n))
except Exception:
pass
n, x = get_coercion_model().canonical_coercion(n, x)
import mpmath
return mpmath_utils.call(mpmath.besselj, n, x, parent=parent)
def __call__(self, x, prec=None, coerce=True, hold=False ):
"""
Note that the ``prec`` argument is deprecated. The precision for
the result is deduced from the precision of the input. Convert
the input to a higher precision explicitly if a result with higher
precision is desired.
EXAMPLES::
sage: t = Ei(RealField(100)(2.5)); t
7.0737658945786007119235519625
sage: t.prec()
100
sage: Ei(1.1, prec=300)
doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.
2.16737827956340306615064476647912607220394065907142504328679588538509331805598360907980986
"""
if prec is not None:
from sage.misc.misc import deprecation
deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.")
import mpmath
return mpmath_utils.call(mpmath.ei, x, prec=prec)
return BuiltinFunction.__call__(self, x, coerce=coerce, hold=hold)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: erf(2).n()
0.995322265018953
sage: erf(2).n(200)
0.99532226501895273416206925636725292861089179704006007673835
sage: erf(pi - 1/2*I).n(100)
1.0000111669099367825726058952 + 1.6332655417638522934072124547e-6*I
TESTS:
Check that PARI/GP through the GP interface gives the same answer::
sage: gp.set_real_precision(59) # random
38
sage: print(gp.eval("1 - erfc(1)")); print(erf(1).n(200));
0.84270079294971486934122063508260925929606699796630290845994
0.84270079294971486934122063508260925929606699796630290845994
Check that for an imaginary input, the output is also imaginary, see
:trac:`13193`::
sage: erf(3.0*I)
1629.99462260157*I
sage: erf(33.0*I)
1.51286977510409e471*I
"""
R = parent or s_parent(x)
import mpmath
return mpmath_utils.call(mpmath.erf, x, parent=R)
def _evalf_(self, a, b, z, parent, algorithm=None):
"""
TESTS::
sage: hypergeometric_M(1,1,1).n()
2.71828182845905
"""
from mpmath import hyp1f1
return mpmath_utils.call(hyp1f1, a, b, z, parent=parent)
def _evalf_(self, a, b, z, parent, algorithm=None):
"""
TESTS::
sage: hypergeometric_U(1,1,1).n()
0.596347362323194
"""
from mpmath import hyperu
return mpmath_utils.call(hyperu, a, b, z, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_I(1,3).n(digits=20)
3.9533702174026093965
"""
import mpmath
return mpmath_utils.call(mpmath.besseli, n, x, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_I(1,3).n(digits=20)
3.9533702174026093965
"""
import mpmath
return mpmath_utils.call(mpmath.besseli, n, x, parent=parent)
def _evalf_(self, a, b, z, parent, algorithm=None):
"""
TESTS::
sage: hypergeometric_U(1,1,1).n()
0.596347362323194
"""
from mpmath import hyperu
return mpmath_utils.call(hyperu, a, b, z, parent=parent)
def _evalf_(self, a, b, z, parent, algorithm=None):
"""
TESTS::
sage: hypergeometric_M(1,1,1).n()
2.71828182845905
"""
from mpmath import hyp1f1
return mpmath_utils.call(hyp1f1, a, b, z, parent=parent)
def __call__(self, x, prec=None, coerce=True, hold=False):
"""
Note that the ``prec`` argument is deprecated. The precision for
the result is deduced from the precision of the input. Convert
the input to a higher precision explicitly if a result with higher
precision is desired.::
sage: t = gamma(RealField(100)(2.5)); t
1.3293403881791370204736256125
sage: t.prec()
100
sage: gamma(6, prec=53)
doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example gamma(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., gamma(1).n(300), instead.
120.000000000000
TESTS::
sage: gamma(pi,prec=100)
2.2880377953400324179595889091
sage: gamma(3/4,prec=100)
1.2254167024651776451290983034
"""
if prec is not None:
from sage.misc.misc import deprecation
deprecation(
"The prec keyword argument is deprecated. Explicitly set the precision of the input, for example gamma(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., gamma(1).n(300), instead."
)
import mpmath
return mpmath_utils.call(mpmath.gamma, x, prec=prec)
# this is a kludge to keep
# sage: Q.<i> = NumberField(x^2+1)
# sage: gamma(i)
# working, since number field elements cannot be coerced into SR
# without specifying an explicit embedding into CC any more
try:
res = GinacFunction.__call__(self, x, coerce=coerce, hold=hold)
except TypeError, err:
# the __call__() method returns a TypeError for fast float arguments
# as well, we only proceed if the error message says that
# the arguments cannot be coerced to SR
if not str(err).startswith("cannot coerce"):
raise
from sage.misc.misc import deprecation
deprecation(
"Calling symbolic functions with arguments that cannot be coerced into symbolic expressions is deprecated."
)
parent = RR if prec is None else RealField(prec)
try:
x = parent(x)
except (ValueError, TypeError):
x = parent.complex_field()(x)
res = GinacFunction.__call__(self, x, coerce=coerce, hold=hold)
def _evalf_(self, n, z, parent=None):
"""
EXAMPLES::
"""
import mpmath
if isinstance(parent, Parent) and hasattr(parent, 'prec'):
prec = parent.prec()
else:
prec = 53
return mpmath_utils.call(mpmath.expint, n, z, prec=prec)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: airy_ai_prime(0.0)
-0.258819403792807
We can use several methods for numerical evaluation::
sage: airy_ai_prime(4).n(algorithm='mpmath')
-0.00195864095020418
sage: airy_ai_prime(4).n(algorithm='mpmath', prec=100)
-0.0019586409502041789001381409184
sage: airy_ai_prime(4).n(algorithm='scipy') # rel tol 1e-10
-0.00195864095020418
sage: airy_ai_prime(I).n(algorithm='scipy') # rel tol 1e-10
-0.43249265984180707 + 0.09804785622924324*I
TESTS::
sage: parent(airy_ai_prime(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_ai_prime(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_ai_prime not implemented
for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError(
"%s not implemented for precision > 53" % self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real, imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[1]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x), imag(x)))[1]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai,
x,
derivative=1,
parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: airy_bi_prime(0.0)
0.448288357353826
We can use several methods for numerical evaluation::
sage: airy_bi_prime(4).n(algorithm='mpmath')
161.926683504613
sage: airy_bi_prime(4).n(algorithm='mpmath', prec=100)
161.92668350461340184309492429
sage: airy_bi_prime(4).n(algorithm='scipy') # rel tol 1e-10
161.92668350461398
sage: airy_bi_prime(I).n(algorithm='scipy') # rel tol 1e-10
0.135026646710819 - 0.1288373867812549*I
TESTS::
sage: parent(airy_bi_prime(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_bi_prime(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_bi_prime not implemented
for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError(
"%s not implemented for precision > 53" % self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real, imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[3]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x), imag(x)))[3]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi,
x,
derivative=1,
parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, n, m, theta, phi, parent, **kwds):
r"""
TESTS::
sage: spherical_harmonic(3 + I, 2, 1, 2).n(100)
-0.35115433730748836508201061672 - 0.41556223397536866209990358597*I
sage: spherical_harmonic(I, I, I, I).n()
7.66678546069894 - 0.265754432549751*I
"""
from mpmath import spherharm
return mpmath_utils.call(spherharm, n, m, theta, phi, parent=parent)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_ai_simple
sage: airy_ai_simple(0.0)
0.355028053887817
sage: airy_ai_simple(1.0 * I)
0.331493305432141 - 0.317449858968444*I
We can use several methods for numerical evaluation::
sage: airy_ai_simple(3).n(algorithm='mpmath')
0.00659113935746072
sage: airy_ai_simple(3).n(algorithm='mpmath', prec=100)
0.0065911393574607191442574484080
sage: airy_ai_simple(3).n(algorithm='scipy') # rel tol 1e-10
0.006591139357460719
sage: airy_ai_simple(I).n(algorithm='scipy') # rel tol 1e-10
0.33149330543214117 - 0.3174498589684438*I
TESTS::
sage: parent(airy_ai_simple(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_ai_simple(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_ai not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent')
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53" % self.name())
from sage.rings.real_mpfr import RR
from sage.rings.cc import CC
from sage.functions.other import real, imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[0]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x), imag(x)))[0]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai, x, parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, a, z, parent=None, algorithm=None):
"""
EXAMPLES::
sage: struve_H(1/2,pi).n()
0.900316316157106
sage: struve_H(1/2,pi).n(200)
0.9003163161571060695551991910...
"""
import mpmath
return mpmath_utils.call(mpmath.struveh, a, z, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
r"""
TESTS::
sage: zetaderiv(0, 3, hold=True).n() == zeta(3).n()
True
sage: zetaderiv(2, 3 + I).n()
0.0213814086193841 - 0.174938812330834*I
"""
from mpmath import zeta
return mpmath_utils.call(zeta, x, 1, n, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_Y(1.0+2*I, 3.0+4*I)
0.699410324467538 + 0.228917940896421*I
sage: bessel_Y(0, 1).n(256)
0.08825696421567695798292676602351516282781752309067554671104384761199978932351
"""
import mpmath
return mpmath_utils.call(mpmath.bessely, n, x, parent=parent)
def _evalf_(self, u, m, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_eu(1,1).n()
0.761594155955765
sage: elliptic_eu(1,1).n(200)
0.7615941559557648881194582...
"""
R = parent or parent(z)
return mpmath_utils.call(elliptic_eu_f, u, m, parent=R)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_K(0.0, 1.0)
0.421024438240708
sage: bessel_K(0, RealField(128)(1))
0.42102443824070833333562737921260903614
"""
import mpmath
return mpmath_utils.call(mpmath.besselk, n, x, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
r"""
TESTS::
sage: zetaderiv(0, 3, hold=True).n() == zeta(3).n()
True
sage: zetaderiv(2, 3 + I).n()
0.0213814086193841 - 0.174938812330834*I
"""
from mpmath import zeta
return mpmath_utils.call(zeta, x, 1, n, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_J(0.0, 1.0)
0.765197686557966
sage: bessel_J(0, 1).n(digits=20)
0.76519768655796655145
"""
import mpmath
return mpmath_utils.call(mpmath.besselj, n, x, parent=parent)
def _evalf_(self, a, z, parent=None, algorithm=None):
"""
EXAMPLES::
sage: struve_L(1/2,pi).n()
4.76805417696286
sage: struve_L(1/2,pi).n(200)
4.768054176962864289162484345...
"""
import mpmath
return mpmath_utils.call(mpmath.struvel, a, z, parent=parent)
def _evalf_(self, u, m, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_eu(1,1).n()
0.761594155955765
sage: elliptic_eu(1,1).n(200)
0.7615941559557648881194582...
"""
R = parent or parent(z)
return mpmath_utils.call(elliptic_eu_f, u, m, parent=R)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_K(0.0, 1.0)
0.421024438240708
sage: bessel_K(0, RealField(128)(1))
0.42102443824070833333562737921260903614
"""
import mpmath
return mpmath_utils.call(mpmath.besselk, n, x, parent=parent)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_bi_simple
sage: airy_bi_simple(0.0)
0.614926627446001
sage: airy_bi_simple(1.0 * I)
0.648858208330395 + 0.344958634768048*I
We can use several methods for numerical evaluation::
sage: airy_bi_simple(3).n(algorithm='mpmath')
14.0373289637302
sage: airy_bi_simple(3).n(algorithm='mpmath', prec=100)
14.037328963730232031740267314
sage: airy_bi_simple(3).n(algorithm='scipy') # rel tol 1e-10
14.037328963730136
sage: airy_bi_simple(I).n(algorithm='scipy') # rel tol 1e-10
0.648858208330395 + 0.34495863476804844*I
TESTS::
sage: parent(airy_bi_simple(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_bi_simple(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_bi not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53" % self.name())
from sage.rings.real_mpfr import RR
from sage.rings.cc import CC
from sage.functions.other import real, imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[2]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x), imag(x)))[2]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi, x, parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_J(0.0, 1.0)
0.765197686557966
sage: bessel_J(0, 1).n(digits=20)
0.76519768655796655145
"""
import mpmath
return mpmath_utils.call(mpmath.besselj, n, x, parent=parent)
def _evalf_(self, n, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: bessel_Y(1.0+2*I, 3.0+4*I)
0.699410324467538 + 0.228917940896421*I
sage: bessel_Y(0, 1).n(256)
0.08825696421567695798292676602351516282781752309067554671104384761199978932351
"""
import mpmath
return mpmath_utils.call(mpmath.bessely, n, x, parent=parent)
def _evalf_(self, alpha, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_ai_general
sage: airy_ai_general(-2, 1.0)
0.136645379421096
"""
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai, x, derivative=alpha,
parent=parent)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: erfinv(0.2)
0.179143454621292
sage: erfinv(1/5).n(100)
0.17914345462129167649274901663
"""
R = parent or s_parent(x)
import mpmath
return mpmath_utils.call(mpmath.erfinv, x, parent=R)
def _evalf_(self, n, z, parent=None):
"""
EXAMPLES::
sage: N(exp_integral_e(1, 1+I))
0.000281624451981418 - 0.179324535039359*I
sage: exp_integral_e(1, RealField(100)(1))
0.21938393439552027367716377546
"""
import mpmath
return mpmath_utils.call(mpmath.expint, n, z, parent=parent)
def _evalf_(self, alpha, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_ai_general
sage: airy_ai_general(-2, 1.0)
0.136645379421096
"""
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai, x, derivative=alpha,
parent=parent)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_bi_simple
sage: airy_bi_simple(0.0)
0.614926627446001
sage: airy_bi_simple(1.0 * I)
0.648858208330395 + 0.344958634768048*I
We can use several methods for numerical evaluation::
sage: airy_bi_simple(3).n(algorithm='mpmath')
14.0373289637302
sage: airy_bi_simple(3).n(algorithm='mpmath', prec=100)
14.037328963730232031740267314
sage: airy_bi_simple(3).n(algorithm='scipy') # rel tol 1e-10
14.037328963730136
sage: airy_bi_simple(I).n(algorithm='scipy') # rel tol 1e-10
0.648858208330395 + 0.34495863476804844*I
TESTS::
sage: parent(airy_bi_simple(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_bi_simple(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_bi not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53"%self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real,imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[2]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x),imag(x)))[2]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi, x, parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_ai_simple
sage: airy_ai_simple(0.0)
0.355028053887817
sage: airy_ai_simple(1.0 * I)
0.331493305432141 - 0.317449858968444*I
We can use several methods for numerical evaluation::
sage: airy_ai_simple(3).n(algorithm='mpmath')
0.00659113935746072
sage: airy_ai_simple(3).n(algorithm='mpmath', prec=100)
0.0065911393574607191442574484080
sage: airy_ai_simple(3).n(algorithm='scipy') # rel tol 1e-10
0.006591139357460719
sage: airy_ai_simple(I).n(algorithm='scipy') # rel tol 1e-10
0.33149330543214117 - 0.3174498589684438*I
TESTS::
sage: parent(airy_ai_simple(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_ai_simple(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_ai not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent')
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53"%self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real,imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[0]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x),imag(x)))[0]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai, x, parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, n, z, parent=None, algorithm=None):
"""
EXAMPLES::
sage: N(exp_integral_e(1, 1+I))
0.000281624451981418 - 0.179324535039359*I
sage: exp_integral_e(1, RealField(100)(1))
0.21938393439552027367716377546
"""
import mpmath
return mpmath_utils.call(mpmath.expint, n, z, parent=parent)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: erfinv(0.2)
0.179143454621292
sage: erfinv(1/5).n(100)
0.17914345462129167649274901663
"""
R = parent or s_parent(x)
import mpmath
return mpmath_utils.call(mpmath.erfinv, x, parent=R)
def __call__(self, x, prec=None, coerce=True, hold=False):
"""
Note that the ``prec`` argument is deprecated. The precision for
the result is deduced from the precision of the input. Convert
the input to a higher precision explicitly if a result with higher
precision is desired.::
sage: t = gamma(RealField(100)(2.5)); t
1.3293403881791370204736256125
sage: t.prec()
100
sage: gamma(6, prec=53)
doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example gamma(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., gamma(1).n(300), instead.
120.000000000000
TESTS::
sage: gamma(pi,prec=100)
2.2880377953400324179595889091
sage: gamma(3/4,prec=100)
1.2254167024651776451290983034
"""
if prec is not None:
from sage.misc.misc import deprecation
deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example gamma(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., gamma(1).n(300), instead.")
import mpmath
return mpmath_utils.call(mpmath.gamma, x, prec=prec)
# this is a kludge to keep
# sage: Q.<i> = NumberField(x^2+1)
# sage: gamma(i)
# working, since number field elements cannot be coerced into SR
# without specifying an explicit embedding into CC any more
try:
res = GinacFunction.__call__(self, x, coerce=coerce, hold=hold)
except TypeError, err:
# the __call__() method returns a TypeError for fast float arguments
# as well, we only proceed if the error message says that
# the arguments cannot be coerced to SR
if not str(err).startswith("cannot coerce"):
raise
from sage.misc.misc import deprecation
deprecation("Calling symbolic functions with arguments that cannot be coerced into symbolic expressions is deprecated.")
parent = RR if prec is None else RealField(prec)
try:
x = parent(x)
except (ValueError, TypeError):
x = parent.complex_field()(x)
res = GinacFunction.__call__(self, x, coerce=coerce, hold=hold)
def _evalf_(self, s, x, parent=None, algorithm=None):
r"""
TESTS::
sage: hurwitz_zeta(11/10, 1/2).n()
12.1038134956837
sage: hurwitz_zeta(11/10, 1/2).n(100)
12.103813495683755105709077413
sage: hurwitz_zeta(11/10, 1 + 1j).n()
9.85014164287853 - 1.06139499403981*I
"""
from mpmath import zeta
return mpmath_utils.call(zeta, s, x, parent=parent)
def _evalf_(self, s, x, parent=None, algorithm=None):
r"""
TESTS::
sage: hurwitz_zeta(11/10, 1/2).n()
12.1038134956837
sage: hurwitz_zeta(11/10, 1/2).n(100)
12.103813495683755105709077413
sage: hurwitz_zeta(11/10, 1 + 1j).n()
9.85014164287853 - 1.06139499403981*I
"""
from mpmath import zeta
return mpmath_utils.call(zeta, s, x, parent=parent)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: airy_ai_prime(0.0)
-0.258819403792807
We can use several methods for numerical evaluation::
sage: airy_ai_prime(4).n(algorithm='mpmath')
-0.00195864095020418
sage: airy_ai_prime(4).n(algorithm='mpmath', prec=100)
-0.0019586409502041789001381409184
sage: airy_ai_prime(4).n(algorithm='scipy') # rel tol 1e-10
-0.00195864095020418
sage: airy_ai_prime(I).n(algorithm='scipy') # rel tol 1e-10
-0.43249265984180707 + 0.09804785622924324*I
TESTS::
sage: parent(airy_ai_prime(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_ai_prime(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_ai_prime not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53"%self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real,imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[1]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x),imag(x)))[1]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airyai, x, derivative=1,
parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, x, **kwargs):
"""
EXAMPLES::
sage: airy_bi_prime(0.0)
0.448288357353826
We can use several methods for numerical evaluation::
sage: airy_bi_prime(4).n(algorithm='mpmath')
161.926683504613
sage: airy_bi_prime(4).n(algorithm='mpmath', prec=100)
161.92668350461340184309492429
sage: airy_bi_prime(4).n(algorithm='scipy') # rel tol 1e-10
161.92668350461398
sage: airy_bi_prime(I).n(algorithm='scipy') # rel tol 1e-10
0.135026646710819 - 0.1288373867812549*I
TESTS::
sage: parent(airy_bi_prime(3).n(algorithm='scipy'))
Real Field with 53 bits of precision
sage: airy_bi_prime(3).n(algorithm='scipy', prec=200)
Traceback (most recent call last):
...
NotImplementedError: airy_bi_prime not implemented for precision > 53
"""
algorithm = kwargs.get('algorithm', 'mpmath') or 'mpmath'
parent = kwargs.get('parent', None)
if algorithm == 'scipy':
if hasattr(parent, 'prec') and parent.prec() > 53:
raise NotImplementedError("%s not implemented for precision > 53"%self.name())
from sage.rings.all import RR, CC
from sage.functions.other import real,imag
from scipy.special import airy as airy
if x in RR:
y = airy(real(x))[3]
if parent is None:
return RR(y)
else:
y = airy(complex(real(x),imag(x)))[3]
if parent is None:
return CC(y)
return parent(y)
elif algorithm == 'mpmath':
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi, x, derivative=1,
parent=parent)
else:
raise ValueError("unknown algorithm '%s'" % algorithm)
def _evalf_(self, z, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_kc(1/2).n()
1.85407467730137
sage: elliptic_kc(1/2).n(200)
1.85407467730137191843385034...
sage: elliptic_kc(I).n()
1.42127228104504 + 0.295380284214777*I
"""
R = parent or parent(z)
from mpmath import ellipk
return mpmath_utils.call(ellipk, z, parent=R)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_ec(sqrt(2)/2).n()
1.23742252487318
sage: elliptic_ec(sqrt(2)/2).n(200)
1.237422524873181672854746084083...
sage: elliptic_ec(I).n()
1.63241178144043 - 0.369219492375499*I
"""
R = parent or parent(z)
from mpmath import ellipe
return mpmath_utils.call(ellipe, x, parent=R)
def _evalf_(self, z, m, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_f(1,1).n()
1.22619117088352
sage: elliptic_f(1,1).n(200)
1.22619117088351707081306096...
sage: elliptic_f(I,I).n()
0.149965060031782 + 0.925097284105771*I
"""
R = parent or parent(z)
from mpmath import ellipf
return mpmath_utils.call(ellipf, z, m, parent=R)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: erfc(4).n()
1.54172579002800e-8
sage: erfc(4).n(100)
1.5417257900280018852159673487e-8
sage: erfc(4*I).n(100)
1.0000000000000000000000000000 - 1.2969597307176392315279409506e6*I
"""
R = parent or s_parent(x)
import mpmath
return mpmath_utils.call(mpmath.erfc, x, parent=R)
def _evalf_(self, z, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_kc(1/2).n()
1.85407467730137
sage: elliptic_kc(1/2).n(200)
1.85407467730137191843385034...
sage: elliptic_kc(I).n()
1.42127228104504 + 0.295380284214777*I
"""
R = parent or parent(z)
from mpmath import ellipk
return mpmath_utils.call(ellipk, z, parent=R)
def _evalf_(self, alpha, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_bi_general
sage: airy_bi_general(-2, 1.0)
0.388621540699059
"""
parent = kwargs.get('parent')
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi, x, derivative=alpha,
parent=parent)
def _evalf_(self, z, m, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_f(1,1).n()
1.22619117088352
sage: elliptic_f(1,1).n(200)
1.22619117088351707081306096...
sage: elliptic_f(I,I).n()
0.149965060031782 + 0.925097284105771*I
"""
R = parent or parent(z)
from mpmath import ellipf
return mpmath_utils.call(ellipf, z, m, parent=R)
def _evalf_(self, alpha, x, **kwargs):
"""
EXAMPLES::
sage: from sage.functions.airy import airy_bi_general
sage: airy_bi_general(-2, 1.0)
0.388621540699059
"""
parent = kwargs.get('parent')
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.airybi, x, derivative=alpha,
parent=parent)
def _evalf_(self, x, parent=None, algorithm=None):
"""
EXAMPLES::
sage: elliptic_ec(sqrt(2)/2).n()
1.23742252487318
sage: elliptic_ec(sqrt(2)/2).n(200)
1.237422524873181672854746084083...
sage: elliptic_ec(I).n()
1.63241178144043 - 0.369219492375499*I
"""
R = parent or parent(z)
from mpmath import ellipe
return mpmath_utils.call(ellipe, x, parent=R)
def _evalf_(self, x, y, parent=None, algorithm='mpmath'):
"""
EXAMPLES::
sage: gamma_inc_lower(3,2.)
0.646647167633873
sage: gamma_inc_lower(3,2).n(200)
0.646647167633873081060005050275155...
sage: gamma_inc_lower(0,2.)
+infinity
"""
R = parent or s_parent(x)
# C is the complex version of R
# prec is the precision of R
if R is float:
prec = 53
C = complex
else:
try:
prec = R.precision()
except AttributeError:
prec = 53
try:
C = R.complex_field()
except AttributeError:
C = R
if algorithm == 'pari':
try:
v = ComplexField(prec)(x).gamma() - ComplexField(prec)(
x).gamma_inc(y)
except AttributeError:
if not (is_ComplexNumber(x)):
if is_ComplexNumber(y):
C = y.parent()
else:
C = ComplexField()
x = C(x)
v = ComplexField(prec)(x).gamma() - ComplexField(prec)(
x).gamma_inc(y)
else:
import mpmath
v = ComplexField(prec)(mpmath_utils.call(mpmath.gammainc,
x,
0,
y,
parent=R))
if v.is_real():
return R(v)
else:
return C(v)
def _evalf_(self, x, parent=None, algorithm=None):
r"""
EXAMPLES::
sage: fresnel_cos(pi)
fresnel_cos(pi)
sage: fresnel_cos(pi).n(100)
0.52369854372622864215767570284
sage: fresnel_cos(1.0+2*I)
16.0878713741255 - 36.2256879928817*I
"""
import mpmath
from sage.libs.mpmath import utils as mpmath_utils
return mpmath_utils.call(mpmath.fresnelc, x, parent=parent)
