Spaces:
Sleeping
Sleeping
File size: 2,279 Bytes
6a86ad5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
from sympy.assumptions import Predicate, AppliedPredicate, Q
from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
from sympy.multipledispatch import Dispatcher
class CommutativePredicate(Predicate):
"""
Commutative predicate.
Explanation
===========
``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other
object with respect to multiplication operation.
"""
# TODO: Add examples
name = 'commutative'
handler = Dispatcher("CommutativeHandler", doc="Handler for key 'commutative'.")
binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
class IsTruePredicate(Predicate):
"""
Generic predicate.
Explanation
===========
``ask(Q.is_true(x))`` is true iff ``x`` is true. This only makes
sense if ``x`` is a boolean object.
Examples
========
>>> from sympy import ask, Q
>>> from sympy.abc import x, y
>>> ask(Q.is_true(True))
True
Wrapping another applied predicate just returns the applied predicate.
>>> Q.is_true(Q.even(x))
Q.even(x)
Wrapping binary relation classes in SymPy core returns applied binary
relational predicates.
>>> from sympy import Eq, Gt
>>> Q.is_true(Eq(x, y))
Q.eq(x, y)
>>> Q.is_true(Gt(x, y))
Q.gt(x, y)
Notes
=====
This class is designed to wrap the boolean objects so that they can
behave as if they are applied predicates. Consequently, wrapping another
applied predicate is unnecessary and thus it just returns the argument.
Also, binary relation classes in SymPy core have binary predicates to
represent themselves and thus wrapping them with ``Q.is_true`` converts them
to these applied predicates.
"""
name = 'is_true'
handler = Dispatcher(
"IsTrueHandler",
doc="Wrapper allowing to query the truth value of a boolean expression."
)
def __call__(self, arg):
# No need to wrap another predicate
if isinstance(arg, AppliedPredicate):
return arg
# Convert relational predicates instead of wrapping them
if getattr(arg, "is_Relational", False):
pred = binrelpreds[type(arg)]
return pred(*arg.args)
return super().__call__(arg)
|