def _eval_is_eq(lhs, rhs): # noqa:F811
# CRootOf represents a Root, so if rhs is that root, it should set
# the expression to zero *and* it should be in the interval of the
# CRootOf instance. It must also be a number that agrees with the
# is_real value of the CRootOf instance.
if not rhs.is_number:
return None
if not rhs.is_finite:
return False
z = lhs.expr.subs(lhs.expr.free_symbols.pop(), rhs).is_zero
if z is False: # all roots will make z True but we don't know
# whether this is the right root if z is True
return False
o = rhs.is_real, rhs.is_imaginary
s = lhs.is_real, lhs.is_imaginary
assert None not in s # this is part of initial refinement
if o != s and None not in o:
return False
re, im = rhs.as_real_imag()
if lhs.is_real:
if im:
return False
i = lhs._get_interval()
a, b = [Rational(str(_)) for _ in (i.a, i.b)]
return sympify(a <= rhs and rhs <= b)
i = lhs._get_interval()
r1, r2, i1, i2 = [Rational(str(j)) for j in (i.ax, i.bx, i.ay, i.by)]
return is_le(r1, re) and is_le(re, r2) and is_le(i1, im) and is_le(im, i2)
def _eval_is_le(lhs, rhs): # noqa: F811
"""
Returns ``True `` if range of values attained by ``lhs`` AccumulationBounds
object is greater than the range of values attained by ``rhs``,
where ``rhs`` may be any value of type AccumulationBounds object or
extended real number value, ``False`` if ``rhs`` satisfies
the same property, else an unevaluated :py:class:`~.Relational`.
Examples
========
>>> from sympy import AccumBounds, oo
>>> AccumBounds(1, 3) > AccumBounds(4, oo)
False
>>> AccumBounds(1, 4) > AccumBounds(3, 4)
AccumBounds(1, 4) > AccumBounds(3, 4)
>>> AccumBounds(1, oo) > -1
True
"""
if not rhs.is_extended_real:
raise TypeError("Invalid comparison of %s %s" % (type(rhs), rhs))
elif rhs.is_comparable:
if is_le(lhs.max, rhs):
return True
if is_gt(lhs.min, rhs):
return False
def _eval_is_ge(lhs, rhs): # noqa:F811
if not lhs.is_extended_real:
raise TypeError("Invalid comparison of %s %s" % (type(lhs), lhs))
elif lhs.is_comparable:
if is_le(rhs.max, lhs):
return True
if is_gt(rhs.min, lhs):
return False
def test_is_ge_le():
class PowTest(Expr):
def __new__(cls, base, exp):
return Basic.__new__(cls, _sympify(base), _sympify(exp))
@dispatch(PowTest, PowTest)
def _eval_is_ge(lhs, rhs):
if type(lhs) == PowTest and type(rhs) == PowTest:
return fuzzy_and([is_ge(lhs.args[0], rhs.args[0]), is_ge(lhs.args[1], rhs.args[1])])
assert is_ge(PowTest(3, 9), PowTest(3,2))
assert is_gt(PowTest(3, 9), PowTest(3,2))
assert is_le(PowTest(3, 2), PowTest(3,9))
assert is_lt(PowTest(3, 2), PowTest(3,9))
def test_is_ge_le():
# test assumptions
assert is_ge(x, S(0), Q.nonnegative(x)) is True
assert is_ge(x, S(0), Q.negative(x)) is False
# test registration
class PowTest(Expr):
def __new__(cls, base, exp):
return Basic.__new__(cls, _sympify(base), _sympify(exp))
@dispatch(PowTest, PowTest)
def _eval_is_ge(lhs, rhs):
if type(lhs) == PowTest and type(rhs) == PowTest:
return fuzzy_and([
is_ge(lhs.args[0], rhs.args[0]),
is_ge(lhs.args[1], rhs.args[1])
])
assert is_ge(PowTest(3, 9), PowTest(3, 2))
assert is_gt(PowTest(3, 9), PowTest(3, 2))
assert is_le(PowTest(3, 2), PowTest(3, 9))
assert is_lt(PowTest(3, 2), PowTest(3, 9))
def test_18778():
raises(TypeError, lambda: is_le(Basic(), Basic()))
raises(TypeError, lambda: is_gt(Basic(), Basic()))
raises(TypeError, lambda: is_ge(Basic(), Basic()))
raises(TypeError, lambda: is_lt(Basic(), Basic()))
def _eval_is_le(lhs, rhs): # noqa:F811
if is_le(lhs.max, rhs.min):
return True
if is_gt(lhs.min, rhs.max):
return False
def eval(self, args, assumptions=True):
return is_le(*args)
def eval(self, args, assumptions=True):
if assumptions == True:
# default assumptions for is_le is None
assumptions = None
return is_le(*args, assumptions)
