def _to_mpmath(self, prec):
# mpmath functions accept ints as input
errmsg = 'cannot convert to mpmath number'
if hasattr(self, '_as_mpf_val'):
return make_mpf(self._as_mpf_val(prec))
try:
re, im, _, _ = evalf(self, prec, {'maxprec': DEFAULT_MAXPREC})
if im:
if not re:
re = fzero
return make_mpc((re, im))
elif re:
return make_mpf(re)
else:
return make_mpf(fzero)
except NotImplementedError as exc:
v = self._eval_evalf(prec) # pylint: disable=assignment-from-none
if v is None:
raise ValueError(errmsg) from exc
re, im = v.as_real_imag()
if re.is_Float:
re = re._mpf_
else:
raise ValueError(errmsg) from exc
if im.is_Float:
im = im._mpf_
else:
raise ValueError(errmsg) from exc
return make_mpc((re, im))
def _to_mpmath(self, prec):
# mpmath functions accept ints as input
errmsg = "cannot convert to mpmath number"
if hasattr(self, '_as_mpf_val'):
return make_mpf(self._as_mpf_val(prec))
try:
re, im, _, _ = evalf(self, prec, {'maxprec': DEFAULT_MAXPREC})
if im:
if not re:
re = fzero
return make_mpc((re, im))
elif re:
return make_mpf(re)
else:
return make_mpf(fzero)
except NotImplementedError:
v = self._eval_evalf(prec)
if v is None:
raise ValueError(errmsg)
re, im = v.as_real_imag()
if re.is_Float:
re = re._mpf_
else:
raise ValueError(errmsg)
if im.is_Float:
im = im._mpf_
else:
raise ValueError(errmsg)
return make_mpc((re, im))
def test_evalf_with_bounded_error():
cases = [
# zero
(Rational(0), None, 1),
# zero im part
(pi, None, 10),
# zero real part
(pi * I, None, 10),
# re and im nonzero
(2 - 3 * I, None, 5),
# similar tests again, but using eps instead of m
(Rational(0), Rational(1, 2), None),
(pi, Rational(1, 1000), None),
(pi * I, Rational(1, 1000), None),
(2 - 3 * I, Rational(1, 1000), None),
# very large eps
(2 - 3 * I, Rational(1000), None),
# case where x already small, hence some cancelation in p = m + n - 1
(Rational(1234, 10**8), Rational(1, 10**12), None),
]
for x0, eps, m in cases:
a, b, _, _ = evalf(x0, 53, {})
c, d, _, _ = _evalf_with_bounded_error(x0, eps, m)
if eps is None:
eps = 2**(-m)
z = make_mpc((a or fzero, b or fzero))
w = make_mpc((c or fzero, d or fzero))
assert abs(w - z) < eps
# eps must be positive
raises(ValueError, lambda: _evalf_with_bounded_error(pi, Rational(0)))
raises(ValueError, lambda: _evalf_with_bounded_error(pi, -pi))
raises(ValueError, lambda: _evalf_with_bounded_error(pi, I))
def _to_mpmath(self, prec, allow_ints=True):
# mpmath functions accept ints as input
errmsg = "cannot convert to mpmath number"
if allow_ints and self.is_Integer:
return self.p
if hasattr(self, '_as_mpf_val'):
return make_mpf(self._as_mpf_val(prec))
try:
re, im, _, _ = evalf(self, prec, {})
if im:
if not re:
re = fzero
return make_mpc((re, im))
elif re:
return make_mpf(re)
else:
return make_mpf(fzero)
except NotImplementedError:
v = self._eval_evalf(prec)
if v is None:
raise ValueError(errmsg)
if v.is_Float:
return make_mpf(v._mpf_)
# Number + Number*I is also fine
re, im = v.as_real_imag()
if allow_ints and re.is_Integer:
re = from_int(re.p)
elif re.is_Float:
re = re._mpf_
else:
raise ValueError(errmsg)
if allow_ints and im.is_Integer:
im = from_int(im.p)
elif im.is_Float:
im = im._mpf_
else:
raise ValueError(errmsg)
return make_mpc((re, im))
def _to_mpmath(self, prec, allow_ints=True):
# mpmath functions accept ints as input
errmsg = "cannot convert to mpmath number"
if allow_ints and self.is_Integer:
return self.p
if hasattr(self, '_as_mpf_val'):
return make_mpf(self._as_mpf_val(prec))
try:
re, im, _, _ = evalf(self, prec, {})
if im:
if not re:
re = fzero
return make_mpc((re, im))
elif re:
return make_mpf(re)
else:
return make_mpf(fzero)
except NotImplementedError:
v = self._eval_evalf(prec)
if v is None:
raise ValueError(errmsg)
if v.is_Float:
return make_mpf(v._mpf_)
# Number + Number*I is also fine
re, im = v.as_real_imag()
if allow_ints and re.is_Integer:
re = from_int(re.p)
elif re.is_Float:
re = re._mpf_
else:
raise ValueError(errmsg)
if allow_ints and im.is_Integer:
im = from_int(im.p)
elif im.is_Float:
im = im._mpf_
else:
raise ValueError(errmsg)
return make_mpc((re, im))
