def test_clear_coefficients():
from sympy.simplify.simplify import clear_coefficients
assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), S(1)/6)
assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + S(1)/6)
assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
def test_clear_coefficients():
from sympy.simplify.simplify import clear_coefficients
assert clear_coefficients(4 * y * (6 * x + 3)) == (y * (2 * x + 1), 0)
assert clear_coefficients(4 * y * (6 * x + 3) - 2) == (y * (2 * x + 1),
S(1) / 6)
assert clear_coefficients(4 * y * (6 * x + 3) - 2,
x) == (y * (2 * x + 1), x / 12 + S(1) / 6)
assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
assert clear_coefficients(4 * sqrt(2) - 2) == (sqrt(2), S.Half)
def test_clear_coefficients():
from sympy.simplify.simplify import clear_coefficients
assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), Rational(1, 6))
assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + Rational(1, 6))
assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
assert clear_coefficients(S(3), x) == (0, x - 3)
assert clear_coefficients(S.Infinity, x) == (S.Infinity, x)
assert clear_coefficients(-S.Pi, x) == (S.Pi, -x)
assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6)
def test_clear_coefficients():
from sympy.simplify.simplify import clear_coefficients
assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), S(1)/6)
assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + S(1)/6)
assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
assert clear_coefficients(S(3), x) == (0, x - 3)
assert clear_coefficients(S.Infinity, x) == (S.Infinity, x)
assert clear_coefficients(-S.Pi, x) == (S.Pi, -x)
assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6)
def is_eq(lhs, rhs, assumptions=None):
"""
Fuzzy bool representing mathematical equality between *lhs* and *rhs*.
Parameters
==========
lhs : Expr
The left-hand side of the expression, must be sympified.
rhs : Expr
The right-hand side of the expression, must be sympified.
assumptions: Boolean, optional
Assumptions taken to evaluate the equality.
Returns
=======
``True`` if *lhs* is equal to *rhs*, ``False`` is *lhs* is not equal to *rhs*,
and ``None`` if the comparison between *lhs* and *rhs* is indeterminate.
Explanation
===========
This function is intended to give a relatively fast determination and
deliberately does not attempt slow calculations that might help in
obtaining a determination of True or False in more difficult cases.
:func:`~.is_neq` calls this function to return its value, so supporting
new type with this function will ensure correct behavior for ``is_neq``
as well.
Examples
========
>>> from sympy import Q, S
>>> from sympy.core.relational import is_eq, is_neq
>>> from sympy.abc import x
>>> is_eq(S(0), S(0))
True
>>> is_neq(S(0), S(0))
False
>>> is_eq(S(0), S(2))
False
>>> is_neq(S(0), S(2))
True
Assumptions can be passed to evaluate the equality which is otherwise
indeterminate.
>>> print(is_eq(x, S(0)))
None
>>> is_eq(x, S(0), assumptions=Q.zero(x))
True
New types can be supported by dispatching to ``_eval_is_eq``.
>>> from sympy import Basic, sympify
>>> from sympy.multipledispatch import dispatch
>>> class MyBasic(Basic):
... def __new__(cls, arg):
... return Basic.__new__(cls, sympify(arg))
... @property
... def value(self):
... return self.args[0]
...
>>> @dispatch(MyBasic, MyBasic)
... def _eval_is_eq(a, b):
... return is_eq(a.value, b.value)
...
>>> a = MyBasic(1)
>>> b = MyBasic(1)
>>> is_eq(a, b)
True
>>> is_neq(a, b)
False
"""
from sympy.assumptions.wrapper import (AssumptionsWrapper, is_infinite,
is_extended_real)
from sympy.core.add import Add
from sympy.functions.elementary.complexes import arg
from sympy.simplify.simplify import clear_coefficients
from sympy.utilities.iterables import sift
# here, _eval_Eq is only called for backwards compatibility
# new code should use is_eq with multiple dispatch as
# outlined in the docstring
for side1, side2 in (lhs, rhs), (rhs, lhs):
eval_func = getattr(side1, '_eval_Eq', None)
if eval_func is not None:
retval = eval_func(side2)
if retval is not None:
return retval
retval = _eval_is_eq(lhs, rhs)
if retval is not None:
return retval
if dispatch(type(lhs), type(rhs)) != dispatch(type(rhs), type(lhs)):
retval = _eval_is_eq(rhs, lhs)
if retval is not None:
return retval
# retval is still None, so go through the equality logic
# If expressions have the same structure, they must be equal.
if lhs == rhs:
return True # e.g. True == True
elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
return False # True != False
elif not (lhs.is_Symbol or rhs.is_Symbol) and (isinstance(lhs, Boolean) !=
isinstance(rhs, Boolean)):
return False # only Booleans can equal Booleans
_lhs = AssumptionsWrapper(lhs, assumptions)
_rhs = AssumptionsWrapper(rhs, assumptions)
if _lhs.is_infinite or _rhs.is_infinite:
if fuzzy_xor([_lhs.is_infinite, _rhs.is_infinite]):
return False
if fuzzy_xor([_lhs.is_extended_real, _rhs.is_extended_real]):
return False
if fuzzy_and([_lhs.is_extended_real, _rhs.is_extended_real]):
return fuzzy_xor([
_lhs.is_extended_positive,
fuzzy_not(_rhs.is_extended_positive)
])
# Try to split real/imaginary parts and equate them
I = S.ImaginaryUnit
def split_real_imag(expr):
real_imag = lambda t: (
'real' if is_extended_real(t, assumptions) else 'imag'
if is_extended_real(I * t, assumptions) else None)
return sift(Add.make_args(expr), real_imag)
lhs_ri = split_real_imag(lhs)
if not lhs_ri[None]:
rhs_ri = split_real_imag(rhs)
if not rhs_ri[None]:
eq_real = is_eq(Add(*lhs_ri['real']), Add(*rhs_ri['real']),
assumptions)
eq_imag = is_eq(I * Add(*lhs_ri['imag']),
I * Add(*rhs_ri['imag']), assumptions)
return fuzzy_and(map(fuzzy_bool, [eq_real, eq_imag]))
# Compare e.g. zoo with 1+I*oo by comparing args
arglhs = arg(lhs)
argrhs = arg(rhs)
# Guard against Eq(nan, nan) -> Falsesymp
if not (arglhs == S.NaN and argrhs == S.NaN):
return fuzzy_bool(is_eq(arglhs, argrhs, assumptions))
if all(isinstance(i, Expr) for i in (lhs, rhs)):
# see if the difference evaluates
dif = lhs - rhs
_dif = AssumptionsWrapper(dif, assumptions)
z = _dif.is_zero
if z is not None:
if z is False and _dif.is_commutative: # issue 10728
return False
if z:
return True
n2 = _n2(lhs, rhs)
if n2 is not None:
return _sympify(n2 == 0)
# see if the ratio evaluates
n, d = dif.as_numer_denom()
rv = None
_n = AssumptionsWrapper(n, assumptions)
_d = AssumptionsWrapper(d, assumptions)
if _n.is_zero:
rv = _d.is_nonzero
elif _n.is_finite:
if _d.is_infinite:
rv = True
elif _n.is_zero is False:
rv = _d.is_infinite
if rv is None:
# if the condition that makes the denominator
# infinite does not make the original expression
# True then False can be returned
l, r = clear_coefficients(d, S.Infinity)
args = [_.subs(l, r) for _ in (lhs, rhs)]
if args != [lhs, rhs]:
rv = fuzzy_bool(is_eq(*args, assumptions))
if rv is True:
rv = None
elif any(is_infinite(a, assumptions) for a in Add.make_args(n)):
# (inf or nan)/x != 0
rv = False
if rv is not None:
return rv
def __new__(cls, lhs, rhs=0, **options):
from sympy.core.add import Add
from sympy.core.logic import fuzzy_bool
from sympy.core.expr import _n2
from sympy.simplify.simplify import clear_coefficients
lhs = _sympify(lhs)
rhs = _sympify(rhs)
evaluate = options.pop('evaluate', global_evaluate[0])
if evaluate:
# If one expression has an _eval_Eq, return its results.
if hasattr(lhs, '_eval_Eq'):
r = lhs._eval_Eq(rhs)
if r is not None:
return r
if hasattr(rhs, '_eval_Eq'):
r = rhs._eval_Eq(lhs)
if r is not None:
return r
# If expressions have the same structure, they must be equal.
if lhs == rhs:
return S.true # e.g. True == True
elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
return S.false # True != False
elif not (lhs.is_Symbol or rhs.is_Symbol) and (isinstance(
lhs, Boolean) != isinstance(rhs, Boolean)):
return S.false # only Booleans can equal Booleans
# check finiteness
fin = L, R = [i.is_finite for i in (lhs, rhs)]
if None not in fin:
if L != R:
return S.false
if L is False:
if lhs == -rhs: # Eq(oo, -oo)
return S.false
return S.true
elif None in fin and False in fin:
return Relational.__new__(cls, lhs, rhs, **options)
if all(isinstance(i, Expr) for i in (lhs, rhs)):
# see if the difference evaluates
dif = lhs - rhs
z = dif.is_zero
if z is not None:
if z is False and dif.is_commutative: # issue 10728
return S.false
if z:
return S.true
# evaluate numerically if possible
n2 = _n2(lhs, rhs)
if n2 is not None:
return _sympify(n2 == 0)
# see if the ratio evaluates
n, d = dif.as_numer_denom()
rv = None
if n.is_zero:
rv = d.is_nonzero
elif n.is_finite:
if d.is_infinite:
rv = S.true
elif n.is_zero is False:
rv = d.is_infinite
if rv is None:
# if the condition that makes the denominator infinite does not
# make the original expression True then False can be returned
l, r = clear_coefficients(d, S.Infinity)
args = [_.subs(l, r) for _ in (lhs, rhs)]
if args != [lhs, rhs]:
rv = fuzzy_bool(Eq(*args))
if rv is True:
rv = None
elif any(a.is_infinite
for a in Add.make_args(n)): # (inf or nan)/x != 0
rv = S.false
if rv is not None:
return _sympify(rv)
return Relational.__new__(cls, lhs, rhs, **options)
def __new__(cls, lhs, rhs=0, **options):
from sympy.core.add import Add
from sympy.core.logic import fuzzy_bool
from sympy.core.expr import _n2
from sympy.simplify.simplify import clear_coefficients
lhs = _sympify(lhs)
rhs = _sympify(rhs)
evaluate = options.pop('evaluate', global_evaluate[0])
if evaluate:
# If one expression has an _eval_Eq, return its results.
if hasattr(lhs, '_eval_Eq'):
r = lhs._eval_Eq(rhs)
if r is not None:
return r
if hasattr(rhs, '_eval_Eq'):
r = rhs._eval_Eq(lhs)
if r is not None:
return r
# If expressions have the same structure, they must be equal.
if lhs == rhs:
return S.true
elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
return S.false
# check finiteness
fin = L, R = [i.is_finite for i in (lhs, rhs)]
if None not in fin:
if L != R:
return S.false
if L is False:
if lhs == -rhs: # Eq(oo, -oo)
return S.false
return S.true
elif None in fin and False in fin:
return Relational.__new__(cls, lhs, rhs, **options)
if all(isinstance(i, Expr) for i in (lhs, rhs)):
# see if the difference evaluates
dif = lhs - rhs
z = dif.is_zero
if z is not None:
if z is False and dif.is_commutative: # issue 10728
return S.false
if z:
return S.true
# evaluate numerically if possible
n2 = _n2(lhs, rhs)
if n2 is not None:
return _sympify(n2 == 0)
# see if the ratio evaluates
n, d = dif.as_numer_denom()
rv = None
if n.is_zero:
rv = d.is_nonzero
elif n.is_finite:
if d.is_infinite:
rv = S.true
elif n.is_zero is False:
rv = d.is_infinite
if rv is None:
# if the condition that makes the denominator infinite does not
# make the original expression True then False can be returned
l, r = clear_coefficients(d, S.Infinity)
args = [_.subs(l, r) for _ in (lhs, rhs)]
if args != [lhs, rhs]:
rv = fuzzy_bool(Eq(*args))
if rv is True:
rv = None
elif any(a.is_infinite for a in Add.make_args(n)): # (inf or nan)/x != 0
rv = S.false
if rv is not None:
return _sympify(rv)
return Relational.__new__(cls, lhs, rhs, **options)
def is_eq(lhs, rhs):
"""
Fuzzy bool representing mathematical equality between lhs and rhs.
Parameters
==========
lhs: Expr
The left-hand side of the expression, must be sympified.
rhs: Expr
The right-hand side of the expression, must be sympified.
Returns
=======
True if lhs is equal to rhs, false is lhs is not equal to rhs, and
None if the comparison between lhs and rhs is indeterminate.
Explanation
===========
This function is intended to give a relatively fast determination and deliberately does not attempt slow
calculations that might help in obtaining a determination of True or False in more difficult cases.
InEquality classes, such as Lt, Gt, etc. Use one of is_ge, is_le, etc.
To implement comparisons with ``Gt(a, b)`` or ``a > b`` etc for an ``Expr`` subclass
it is only necessary to define a dispatcher method for ``_eval_is_ge`` like
>>> from sympy.core.relational import is_eq
>>> from sympy.core.relational import is_neq
>>> from sympy import S, Basic, Eq, sympify
>>> from sympy.abc import x
>>> from sympy.multipledispatch import dispatch
>>> class MyBasic(Basic):
... def __new__(cls, arg):
... return Basic.__new__(cls, sympify(arg))
... @property
... def value(self):
... return self.args[0]
...
>>> @dispatch(MyBasic, MyBasic)
... def _eval_is_eq(a, b):
... return is_eq(a.value, b.value)
...
>>> a = MyBasic(1)
>>> b = MyBasic(1)
>>> a == b
True
>>> Eq(a, b)
True
>>> a != b
False
>>> is_eq(a, b)
True
Examples
========
>>> is_eq(S(0), S(0))
True
>>> Eq(0, 0)
True
>>> is_neq(S(0), S(0))
False
>>> is_eq(S(0), S(2))
False
>>> Eq(0, 2)
False
>>> is_neq(S(0), S(2))
True
>>> is_eq(S(0), x)
>>> Eq(S(0), x)
Eq(0, x)
"""
from sympy.core.add import Add
from sympy.functions.elementary.complexes import arg
from sympy.simplify.simplify import clear_coefficients
from sympy.utilities.iterables import sift
# here, _eval_Eq is only called for backwards compatibility
# new code should use is_eq with multiple dispatch as
# outlined in the docstring
for side1, side2 in (lhs, rhs), (rhs, lhs):
eval_func = getattr(side1, '_eval_Eq', None)
if eval_func is not None:
retval = eval_func(side2)
if retval is not None:
return retval
retval = _eval_is_eq(lhs, rhs)
if retval is not None:
return retval
if dispatch(type(lhs), type(rhs)) != dispatch(type(rhs), type(lhs)):
retval = _eval_is_eq(rhs, lhs)
if retval is not None:
return retval
# retval is still None, so go through the equality logic
# If expressions have the same structure, they must be equal.
if lhs == rhs:
return True # e.g. True == True
elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
return False # True != False
elif not (lhs.is_Symbol or rhs.is_Symbol) and (isinstance(lhs, Boolean) !=
isinstance(rhs, Boolean)):
return False # only Booleans can equal Booleans
if lhs.is_infinite or rhs.is_infinite:
if fuzzy_xor([lhs.is_infinite, rhs.is_infinite]):
return False
if fuzzy_xor([lhs.is_extended_real, rhs.is_extended_real]):
return False
if fuzzy_and([lhs.is_extended_real, rhs.is_extended_real]):
return fuzzy_xor([
lhs.is_extended_positive,
fuzzy_not(rhs.is_extended_positive)
])
# Try to split real/imaginary parts and equate them
I = S.ImaginaryUnit
def split_real_imag(expr):
real_imag = lambda t: ('real' if t.is_extended_real else 'imag'
if (I * t).is_extended_real else None)
return sift(Add.make_args(expr), real_imag)
lhs_ri = split_real_imag(lhs)
if not lhs_ri[None]:
rhs_ri = split_real_imag(rhs)
if not rhs_ri[None]:
eq_real = Eq(Add(*lhs_ri['real']), Add(*rhs_ri['real']))
eq_imag = Eq(I * Add(*lhs_ri['imag']),
I * Add(*rhs_ri['imag']))
return fuzzy_and(map(fuzzy_bool, [eq_real, eq_imag]))
# Compare e.g. zoo with 1+I*oo by comparing args
arglhs = arg(lhs)
argrhs = arg(rhs)
# Guard against Eq(nan, nan) -> Falsesymp
if not (arglhs == S.NaN and argrhs == S.NaN):
return fuzzy_bool(Eq(arglhs, argrhs))
if all(isinstance(i, Expr) for i in (lhs, rhs)):
# see if the difference evaluates
dif = lhs - rhs
z = dif.is_zero
if z is not None:
if z is False and dif.is_commutative: # issue 10728
return False
if z:
return True
n2 = _n2(lhs, rhs)
if n2 is not None:
return _sympify(n2 == 0)
# see if the ratio evaluates
n, d = dif.as_numer_denom()
rv = None
if n.is_zero:
rv = d.is_nonzero
elif n.is_finite:
if d.is_infinite:
rv = True
elif n.is_zero is False:
rv = d.is_infinite
if rv is None:
# if the condition that makes the denominator
# infinite does not make the original expression
# True then False can be returned
l, r = clear_coefficients(d, S.Infinity)
args = [_.subs(l, r) for _ in (lhs, rhs)]
if args != [lhs, rhs]:
rv = fuzzy_bool(Eq(*args))
if rv is True:
rv = None
elif any(a.is_infinite for a in Add.make_args(n)):
# (inf or nan)/x != 0
rv = False
if rv is not None:
return rv
def __new__(cls, lhs, rhs=None, **options):
from sympy.core.add import Add
from sympy.core.containers import Tuple
from sympy.core.logic import fuzzy_bool, fuzzy_xor, fuzzy_and, fuzzy_not
from sympy.core.expr import _n2
from sympy.functions.elementary.complexes import arg
from sympy.simplify.simplify import clear_coefficients
from sympy.utilities.iterables import sift
if rhs is None:
SymPyDeprecationWarning(feature="Eq(expr) with rhs default to 0",
useinstead="Eq(expr, 0)",
issue=16587,
deprecated_since_version="1.5").warn()
rhs = 0
lhs = _sympify(lhs)
rhs = _sympify(rhs)
evaluate = options.pop('evaluate', global_parameters.evaluate)
if evaluate:
# If one expression has an _eval_Eq, return its results.
if hasattr(lhs, '_eval_Eq'):
r = lhs._eval_Eq(rhs)
if r is not None:
return r
if hasattr(rhs, '_eval_Eq'):
r = rhs._eval_Eq(lhs)
if r is not None:
return r
# If expressions have the same structure, they must be equal.
if lhs == rhs:
return S.true # e.g. True == True
elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
return S.false # True != False
elif not (lhs.is_Symbol or rhs.is_Symbol) and (isinstance(
lhs, Boolean) != isinstance(rhs, Boolean)):
return S.false # only Booleans can equal Booleans
if lhs.is_infinite or rhs.is_infinite:
if fuzzy_xor([lhs.is_infinite, rhs.is_infinite]):
return S.false
if fuzzy_xor([lhs.is_extended_real, rhs.is_extended_real]):
return S.false
if fuzzy_and([lhs.is_extended_real, rhs.is_extended_real]):
r = fuzzy_xor([
lhs.is_extended_positive,
fuzzy_not(rhs.is_extended_positive)
])
return S(r)
# Try to split real/imaginary parts and equate them
I = S.ImaginaryUnit
def split_real_imag(expr):
real_imag = lambda t: ('real'
if t.is_extended_real else 'imag' if
(I * t).is_extended_real else None)
return sift(Add.make_args(expr), real_imag)
lhs_ri = split_real_imag(lhs)
if not lhs_ri[None]:
rhs_ri = split_real_imag(rhs)
if not rhs_ri[None]:
eq_real = Eq(Add(*lhs_ri['real']),
Add(*rhs_ri['real']))
eq_imag = Eq(I * Add(*lhs_ri['imag']),
I * Add(*rhs_ri['imag']))
res = fuzzy_and(map(fuzzy_bool, [eq_real, eq_imag]))
if res is not None:
return S(res)
# Compare e.g. zoo with 1+I*oo by comparing args
arglhs = arg(lhs)
argrhs = arg(rhs)
# Guard against Eq(nan, nan) -> False
if not (arglhs == S.NaN and argrhs == S.NaN):
res = fuzzy_bool(Eq(arglhs, argrhs))
if res is not None:
return S(res)
return Relational.__new__(cls, lhs, rhs, **options)
if all(isinstance(i, Expr) for i in (lhs, rhs)):
# see if the difference evaluates
dif = lhs - rhs
z = dif.is_zero
if z is not None:
if z is False and dif.is_commutative: # issue 10728
return S.false
if z:
return S.true
# evaluate numerically if possible
n2 = _n2(lhs, rhs)
if n2 is not None:
return _sympify(n2 == 0)
# see if the ratio evaluates
n, d = dif.as_numer_denom()
rv = None
if n.is_zero:
rv = d.is_nonzero
elif n.is_finite:
if d.is_infinite:
rv = S.true
elif n.is_zero is False:
rv = d.is_infinite
if rv is None:
# if the condition that makes the denominator
# infinite does not make the original expression
# True then False can be returned
l, r = clear_coefficients(d, S.Infinity)
args = [_.subs(l, r) for _ in (lhs, rhs)]
if args != [lhs, rhs]:
rv = fuzzy_bool(Eq(*args))
if rv is True:
rv = None
elif any(a.is_infinite for a in Add.make_args(n)):
# (inf or nan)/x != 0
rv = S.false
if rv is not None:
return _sympify(rv)
return Relational.__new__(cls, lhs, rhs, **options)