def _eval_evalf(self, prec):
"""Evaluate this complex root to the given precision. """
_prec, mp.prec = mp.prec, prec
try:
func = lambdify(self.poly.gen, self.expr)
interval, refined = self._get_interval(), False
while True:
if self.is_real:
x0 = mpf(str(interval.center))
else:
re, im = interval.center
re = mpf(str(re))
im = mpf(str(im))
x0 = mpc(re, im)
try:
root = findroot(func, x0)
except ValueError:
interval = interval.refine()
refined = True
continue
else:
if refined:
self._set_interval(interval)
if self.is_conjugate:
root = root.conjugate()
break
finally:
mp.prec = _prec
return Real._new(root.real._mpf_,
prec) + I * Real._new(root.imag._mpf_, prec)
def _eval_evalf(self, prec):
"""Evaluate this complex root to the given precision. """
_prec, mp.prec = mp.prec, prec
try:
func = lambdify(self.poly.gen, self.expr)
interval, refined = self._get_interval(), False
while True:
if self.is_real:
x0 = mpf(str(interval.center))
else:
re, im = interval.center
re = mpf(str(re))
im = mpf(str(im))
x0 = mpc(re, im)
try:
root = findroot(func, x0)
except ValueError:
interval = interval.refine()
refined = True
continue
else:
if refined:
self._set_interval(interval)
if self.is_conjugate:
root = root.conjugate()
break
finally:
mp.prec = _prec
return Real._new(root.real._mpf_, prec) + I*Real._new(root.imag._mpf_, prec)
def confidence(s, p):
"""Return a symmetric (p*100)% confidence interval. For example,
p=0.95 gives a 95% confidence interval. Currently this function
only handles numerical values except in the trivial case p=1.
Examples usage:
# One standard deviation
>>> from sympy.statistics import Normal
>>> N = Normal(0, 1)
>>> N.confidence(0.68)
(-0.994457883209753, 0.994457883209753)
>>> N.probability(*_).evalf()
0.680000000000000
# Two standard deviations
>>> N = Normal(0, 1)
>>> N.confidence(0.95)
(-1.95996398454005, 1.95996398454005)
>>> N.probability(*_).evalf()
0.950000000000000
"""
if p == 1:
return (-oo, oo)
assert p <= 1
# In terms of n*sigma, we have n = sqrt(2)*ierf(p). The inverse
# error function is not yet implemented in SymPy but can easily be
# computed numerically
from sympy.mpmath import mpf, erfinv
# calculate y = ierf(p) by solving erf(y) - p = 0
y = erfinv(mpf(p))
t = Real(str(mpf(float(s.sigma)) * mpf(2)**0.5 * y))
mu = s.mu.evalf()
return (mu-t, mu+t)
def test_negative_real():
def feq(a, b):
return abs(a - b) < 1E-10
assert feq(S.One / Real(-0.5), -Integer(2))
def _random(s):
return Real(random.uniform(float(s.a), float(s.b)))