ó ~9­\c@ sVddlmZmZddlmZmZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZdd lmZmZd d d dddddddddddfZd„Zdee e fd„ƒYZeZdefd„ƒYZeZdefd„ƒYZeZdefd„ƒYZdefd „ƒYZd!efd"„ƒYZdefd#„ƒYZ e Z!defd$„ƒYZ"e"Z#defd%„ƒYZ$e$Z%defd&„ƒYZ&e&Z'iee(6ed'6ed(6ed)6ed*6ed+6e d,6e d-6e"d.6e"d/6e$d06e$d16e&d26e&d36e_)d4S(5iÿÿÿÿ(tprint_functiontdivisioni(t_unevaluated_AddtAdd(tS(tordered(tExpr(t EvalfMixin(t_sympify(tglobal_evaluate(tBooleant BooleanAtomtReltEqtNetLttLetGttGet RelationaltEqualityt UnequalitytStrictLessThantLessThantStrictGreaterThant GreaterThancC s&d„|jtƒDƒ}|j|ƒS(NcS si|]}|j|“qS((t canonical(t.0tr((s4lib/python2.7/site-packages/sympy/core/relational.pys s (tatomsRtxreplace(tcondtreps((s4lib/python2.7/site-packages/sympy/core/relational.pyt _canonicalscB sÅeZdZgZeZdd„Zed„ƒZ ed„ƒZ ed„ƒZ ed„ƒZ ed„ƒZ d„Zed„ƒZed „Zd „Zd „ZeZd „Zed „ƒZRS(s)Base class for all relation types. Subclasses of Relational should generally be instantiated directly, but Relational can be instantiated with a valid `rop` value to dispatch to the appropriate subclass. Parameters ========== rop : str or None Indicates what subclass to instantiate. Valid values can be found in the keys of Relational.ValidRelationalOperator. Examples ======== >>> from sympy import Rel >>> from sympy.abc import x, y >>> Rel(y, x + x**2, '==') Eq(y, x**2 + x) c K s|tk r"tj||||SyÎ|j|}||||}t|ttfƒr\nt|tƒrëddlm}ddl m }x]|j D]O}t||ƒr°q•nt||ƒr•ddl m } t| dƒƒ‚q•q•Wn|SWn!tk rtd|ƒ‚nXdS(Niÿÿÿÿ(tSymbol(R (t filldedentsÎ A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. s&Invalid relational operator symbol: %r(RRt__new__tValidRelationOperatort isinstanceR Rtsympy.core.symbolR"tsympy.logic.boolalgR targstsympy.utilities.miscR#t TypeErrortKeyErrort ValueError( tclstlhstrhstropt assumptionstrvR"R taR#((s4lib/python2.7/site-packages/sympy/core/relational.pyR$<s*   cC s |jdS(s#The left-hand side of the relation.i(t_args(tself((s4lib/python2.7/site-packages/sympy/core/relational.pyR/]scC s |jdS(s$The right-hand side of the relation.i(R5(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyR0bscC sditt6tt6tt6tt6tt6tt6}|j\}}tj|j |j |j ƒ||ƒS(s1Return the relationship with sides reversed. Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x, 1) Eq(x, 1) >>> _.reversed Eq(1, x) >>> x < 1 x < 1 >>> _.reversed 1 > x ( R RRRRRR)RR$tgettfunc(R6topsR4tb((s4lib/python2.7/site-packages/sympy/core/relational.pytreversedgs0cC sŒ|j\}}t|tƒp*t|tƒs„itt6tt6tt6tt6tt6tt6}t j |j |j |j ƒ| | ƒS|SdS(s=Return the relationship with signs reversed. Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x, 1) Eq(x, 1) >>> _.reversedsign Eq(-x, -1) >>> x < 1 x < 1 >>> _.reversedsign -x > -1 N( R)R&R R RRRRRRR$R7R8(R6R4R:R9((s4lib/python2.7/site-packages/sympy/core/relational.pyt reversedsign}s 0'cC sOitt6tt6tt6tt6tt6tt6}tj|j|j ƒ|j ŒS(syReturn the negated relationship. Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x, 1) Eq(x, 1) >>> _.negated Ne(x, 1) >>> x < 1 x < 1 >>> _.negated x >= 1 Notes ===== This works more or less identical to ``~``/``Not``. The difference is that ``negated`` returns the relationship even if `evaluate=False`. Hence, this is useful in code when checking for e.g. negated relations to exisiting ones as it will not be affected by the `evaluate` flag. ( RR RRRRRR$R7R8R)(R6R9((s4lib/python2.7/site-packages/sympy/core/relational.pytnegated–s0cC s,|jg|jD]}|j|ƒ^qŒS(N(R8R)t_evalf(R6tprects((s4lib/python2.7/site-packages/sympy/core/relational.pyt _eval_evalf¸scC s1|j}|}|jjrT|jjr|jjr|j|jkr|j}qn<|jjrl|j}n$tt|ƒƒ|kr|j}nt|jt ƒ r¾|jj ƒr¾|j }not|jt ƒ r-|jj r-|jj ƒr-t|j|j gƒ\}}||jkr-|jj }q-n|S(sûReturn a canonical form of the relational by putting a Number on the rhs else ordering the args. The relation is also changed so that the left-hand side expression does not start with a `-`. No other simplification is attempted. Examples ======== >>> from sympy.abc import x, y >>> x < 2 x < 2 >>> _.reversed.canonical x < 2 >>> (-y < x).canonical x > -y >>> (-y > x).canonical x < -y ( R)R0t is_numbert is_NumberR/R;ttupleRR&R tcould_extract_minus_signR<(R6R)Rtexpr1t_((s4lib/python2.7/site-packages/sympy/core/relational.pyR»s$  *     c C s?t|tƒr;||ks*|j|kr.tS||}}|jttfkse|jttfkrš|j|jkr{tSgt|j |j ƒD]!\}}|j |d|ƒ^q‘\}}|tkrÎ|S|tkrÞ|Sgt|j |jj ƒD]!\}}|j |d|ƒ^q÷\} } | tkr4| S| tkrD| S||| | f} t d„| DƒƒrptSxÅ| D]}|ttfkrw|SqwWq;|j|jkr¸|j}n|j|jkrÎtS|j j |j d|ƒ}|tkrùtS|j j |j d|ƒ}|tkr$tS|tkr4|S|SndS(sßReturn True if the sides of the relationship are mathematically identical and the type of relationship is the same. If failing_expression is True, return the expression whose truth value was unknown.tfailing_expressioncs s|]}|tkVqdS(N(tFalse(Rti((s4lib/python2.7/site-packages/sympy/core/relational.pys sN(R&RR;tTrueR8R RRItzipR)tequalstallR/R0( R6totherRHR4R:RJtjtlefttrighttlrtrlte((s4lib/python2.7/site-packages/sympy/core/relational.pyRMèsP *@  C          c C sù|}|jg|jD]*}|jd|d|d|d|ƒ^qŒ}|jrÈ|j|j}d}|jrƒ|jdƒ}n|j dƒržt j }n|dk rÈ|jj |t j ƒ}qÈn|j }||ƒ|||ƒkrñ|S|SdS(Ntratiotmeasuretrationaltinverseii(R8R)tsimplifyt is_RelationalR/R0tNonet is_comparabletnRMRtZerot_eval_relationR( R6RVRWRXRYRRJtdiftv((s4lib/python2.7/site-packages/sympy/core/relational.pyt_eval_simplifys  :     cC stdƒ‚dS(Ns*cannot determine truth value of Relational(R+(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyt __nonzero__/scC sPddlm}|j}t|ƒdks1t‚|jƒ}|||dtƒS(Niÿÿÿÿ(tsolve_univariate_inequalityit relational(tsympy.solvers.inequalitiesRet free_symbolstlentAssertionErrortpopRI(R6Retsymstx((s4lib/python2.7/site-packages/sympy/core/relational.pyt _eval_as_set4s   cC stƒS(N(tset(R6((s4lib/python2.7/site-packages/sympy/core/relational.pytbinary_symbols<sN(t__name__t __module__t__doc__t __slots__RKR[R\R$tpropertyR/R0R;R<R=RARRIRMRcRdt__bool__RnRp(((s4lib/python2.7/site-packages/sympy/core/relational.pyRs" !" - 0   cB s\eZdZdZgZeZdd„Zed„ƒZ d„Z e d„ƒZ d„Z RS(s°An equal relation between two objects. Represents that two objects are equal. If they can be easily shown to be definitively equal (or unequal), this will reduce to True (or False). Otherwise, the relation is maintained as an unevaluated Equality object. Use the ``simplify`` function on this object for more nontrivial evaluation of the equality relation. As usual, the keyword argument ``evaluate=False`` can be used to prevent any evaluation. Examples ======== >>> from sympy import Eq, simplify, exp, cos >>> from sympy.abc import x, y >>> Eq(y, x + x**2) Eq(y, x**2 + x) >>> Eq(2, 5) False >>> Eq(2, 5, evaluate=False) Eq(2, 5) >>> _.doit() False >>> Eq(exp(x), exp(x).rewrite(cos)) Eq(exp(x), sinh(x) + cosh(x)) >>> simplify(_) True See Also ======== sympy.logic.boolalg.Equivalent : for representing equality between two boolean expressions Notes ===== This class is not the same as the == operator. The == operator tests for exact structural equality between two expressions; this class compares expressions mathematically. If either object defines an `_eval_Eq` method, it can be used in place of the default algorithm. If `lhs._eval_Eq(rhs)` or `rhs._eval_Eq(lhs)` returns anything other than None, that return value will be substituted for the Equality. If None is returned by `_eval_Eq`, an Equality object will be created as usual. Since this object is already an expression, it does not respond to the method `as_expr` if one tries to create `x - y` from Eq(x, y). This can be done with the `rewrite(Add)` method. s==icK sÍddlm}ddlm}ddlm}ddlm}t|ƒ}t|ƒ}|j dt dƒ}|r·t |dƒr¥|j |ƒ} | dk r¥| Snt |dƒrÖ|j |ƒ} | dk rÖ| Sn||krétjStd „||fDƒƒr tjS|jp|j rDt|tƒt|tƒkrDtjSg||fD]} | j^qQ} \} } d| kr¹| | krtjS| tkrç|| kr¯tjStjSn.d| krçt| krçtj||||Std „||fDƒƒr·||}|j}|dk rN|tkr>|jr>tjS|rNtjSn|||ƒ}|dk ryt|dkƒS|jƒ\}}d}|jr¦|j}nõ|jrp|jrÄtj}q›|jtkr›|j}|dkrm||tjƒ\}} g||fD]}|j|| ƒ^q }|||gkrj|t |Œƒ}|t!krgd}qgqjqmq›n+t"d „|j#|ƒDƒƒr›tj}n|dk r´t|ƒSq·ntj||||S( Niÿÿÿÿ(R(t fuzzy_bool(t_n2(tclear_coefficientstevaluateit_eval_Eqcs s|]}t|tƒVqdS(N(R&R (RRJ((s4lib/python2.7/site-packages/sympy/core/relational.pys ˜scs s|]}t|tƒVqdS(N(R&R(RRJ((s4lib/python2.7/site-packages/sympy/core/relational.pys «scs s|]}|jVqdS(N(t is_infinite(RR4((s4lib/python2.7/site-packages/sympy/core/relational.pys Ìs($tsympy.core.addRtsympy.core.logicRwtsympy.core.exprRxtsympy.simplify.simplifyRyRRkR thasattrR{R\RttrueRNtfalset is_SymbolR&R t is_finiteRIRR$tis_zerotis_commutativetas_numer_denomt is_nonzeroR|tInfinitytsubsR RKtanyt make_args(R.R/R0toptionsRRwRxRyRzRRJtfintLtRRatztn2R^tdR3tlRGR)((s4lib/python2.7/site-packages/sympy/core/relational.pyR$€s„      ,                 +   cC st||kƒS(N(R(R.R/R0((s4lib/python2.7/site-packages/sympy/core/relational.pyR`ÔscO sl|\}}|jdtƒ}|r,||Stj|ƒtj| ƒ}|dkr_t|ŒStj|ƒS(snreturn Eq(L, R) as L - R. To control the evaluation of the result set pass `evaluate=True` to give L - R; if `evaluate=None` then terms in L and R will not cancel but they will be listed in canonical order; otherwise non-canonical args will be returned. Examples ======== >>> from sympy import Eq, Add >>> from sympy.abc import b, x >>> eq = Eq(x + b, x - b) >>> eq.rewrite(Add) 2*b >>> eq.rewrite(Add, evaluate=None).args (b, b, x, -x) >>> eq.rewrite(Add, evaluate=False).args (b, x, b, -x) RzN(R7RKRRR\Rt _from_args(R6R)tkwargsRR‘Rz((s4lib/python2.7/site-packages/sympy/core/relational.pyt_eval_rewrite_as_AddØs   cC sftj|jks$tj|jkr_|jjr@t|jgƒS|jjr_t|jgƒSntƒS(N(RR‚R)RƒR/R„RoR0(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyRpøs $  c C sddlm}tt|ƒj||||ƒ}t|tƒsD|S|j}t|ƒdkry™|jƒ}||j t dt ƒ|ƒ\} } | j t kr»|j || | ƒ} n|j | || ƒ} || ƒ|||ƒkr÷| }nWqtk r qXn|jS(Niÿÿÿÿ(t linear_coeffsiRz(tsympy.solvers.solvesetR™tsuperRRcR&RhRiRktrewriteRRIR†R8R-R( R6RVRWRXRYR™RUtfreeRmtmR:tenew((s4lib/python2.7/site-packages/sympy/core/relational.pyRcs&  !  (RqRrRstrel_opRtRKt is_EqualityR$t classmethodR`R˜RuRpRc(((s4lib/python2.7/site-packages/sympy/core/relational.pyREs4 T  cB sJeZdZdZgZd„Zed„ƒZed„ƒZ d„Z RS(s3An unequal relation between two objects. Represents that two objects are not equal. If they can be shown to be definitively equal, this will reduce to False; if definitively unequal, this will reduce to True. Otherwise, the relation is maintained as an Unequality object. Examples ======== >>> from sympy import Ne >>> from sympy.abc import x, y >>> Ne(y, x+x**2) Ne(y, x**2 + x) See Also ======== Equality Notes ===== This class is not the same as the != operator. The != operator tests for exact structural equality between two expressions; this class compares expressions mathematically. This class is effectively the inverse of Equality. As such, it uses the same algorithms, including any available `_eval_Eq` methods. s!=cK srt|ƒ}t|ƒ}|jdtdƒ}|r\t||ƒ}t|tƒr\|jSntj||||S(NRzi( RRkR RR&R R=RR$(R.R/R0RŽRztis_equal((s4lib/python2.7/site-packages/sympy/core/relational.pyR$>s   cC st||kƒS(N(R(R.R/R0((s4lib/python2.7/site-packages/sympy/core/relational.pyR`KscC sftj|jks$tj|jkr_|jjr@t|jgƒS|jjr_t|jgƒSntƒS(N(RR‚R)RƒR/R„RoR0(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyRpOs $  cC sGt|jŒj||||ƒ}t|tƒr@|j|jŒS|jS(N(RR)RcR&R8R=(R6RVRWRXRYteq((s4lib/python2.7/site-packages/sympy/core/relational.pyRcXs ( RqRrRsR RtR$R¢R`RuRpRc(((s4lib/python2.7/site-packages/sympy/core/relational.pyRs  t _InequalitycB seZdZgZd„ZRS(s™Internal base class for all *Than types. Each subclass must implement _eval_relation to provide the method for comparing two real numbers. cK sot|ƒ}t|ƒ}|jdtdƒ}|rY|j||ƒ}|dk rY|Sntj||||S(NRzi(RRkR R`R\RR$(R.R/R0RŽRzR((s4lib/python2.7/site-packages/sympy/core/relational.pyR$ns    (RqRrRsRtR$(((s4lib/python2.7/site-packages/sympy/core/relational.pyR¥est_GreatercB s2eZdZdZed„ƒZed„ƒZRS(sNot intended for general use _Greater is only used so that GreaterThan and StrictGreaterThan may subclass it for the .gts and .lts properties. cC s |jdS(Ni(R5(R6((s4lib/python2.7/site-packages/sympy/core/relational.pytgts‘scC s |jdS(Ni(R5(R6((s4lib/python2.7/site-packages/sympy/core/relational.pytlts•s((RqRrRsRtRuR§R¨(((s4lib/python2.7/site-packages/sympy/core/relational.pyR¦ˆst_LesscB s2eZdZdZed„ƒZed„ƒZRS(s•Not intended for general use. _Less is only used so that LessThan and StrictLessThan may subclass it for the .gts and .lts properties. cC s |jdS(Ni(R5(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyR§£scC s |jdS(Ni(R5(R6((s4lib/python2.7/site-packages/sympy/core/relational.pyR¨§s((RqRrRsRtRuR§R¨(((s4lib/python2.7/site-packages/sympy/core/relational.pyR©šscB s)eZdZdZdZed„ƒZRS(sÆClass representations of inequalities. Extended Summary ================ The ``*Than`` classes represent inequal relationships, where the left-hand side is generally bigger or smaller than the right-hand side. For example, the GreaterThan class represents an inequal relationship where the left-hand side is at least as big as the right side, if not bigger. In mathematical notation: lhs >= rhs In total, there are four ``*Than`` classes, to represent the four inequalities: +-----------------+--------+ |Class Name | Symbol | +=================+========+ |GreaterThan | (>=) | +-----------------+--------+ |LessThan | (<=) | +-----------------+--------+ |StrictGreaterThan| (>) | +-----------------+--------+ |StrictLessThan | (<) | +-----------------+--------+ All classes take two arguments, lhs and rhs. +----------------------------+-----------------+ |Signature Example | Math equivalent | +============================+=================+ |GreaterThan(lhs, rhs) | lhs >= rhs | +----------------------------+-----------------+ |LessThan(lhs, rhs) | lhs <= rhs | +----------------------------+-----------------+ |StrictGreaterThan(lhs, rhs) | lhs > rhs | +----------------------------+-----------------+ |StrictLessThan(lhs, rhs) | lhs < rhs | +----------------------------+-----------------+ In addition to the normal .lhs and .rhs of Relations, ``*Than`` inequality objects also have the .lts and .gts properties, which represent the "less than side" and "greater than side" of the operator. Use of .lts and .gts in an algorithm rather than .lhs and .rhs as an assumption of inequality direction will make more explicit the intent of a certain section of code, and will make it similarly more robust to client code changes: >>> from sympy import GreaterThan, StrictGreaterThan >>> from sympy import LessThan, StrictLessThan >>> from sympy import And, Ge, Gt, Le, Lt, Rel, S >>> from sympy.abc import x, y, z >>> from sympy.core.relational import Relational >>> e = GreaterThan(x, 1) >>> e x >= 1 >>> '%s >= %s is the same as %s <= %s' % (e.gts, e.lts, e.lts, e.gts) 'x >= 1 is the same as 1 <= x' Examples ======== One generally does not instantiate these classes directly, but uses various convenience methods: >>> for f in [Ge, Gt, Le, Lt]: # convenience wrappers ... print(f(x, 2)) x >= 2 x > 2 x <= 2 x < 2 Another option is to use the Python inequality operators (>=, >, <=, <) directly. Their main advantage over the Ge, Gt, Le, and Lt counterparts, is that one can write a more "mathematical looking" statement rather than littering the math with oddball function calls. However there are certain (minor) caveats of which to be aware (search for 'gotcha', below). >>> x >= 2 x >= 2 >>> _ == Ge(x, 2) True However, it is also perfectly valid to instantiate a ``*Than`` class less succinctly and less conveniently: >>> Rel(x, 1, ">") x > 1 >>> Relational(x, 1, ">") x > 1 >>> StrictGreaterThan(x, 1) x > 1 >>> GreaterThan(x, 1) x >= 1 >>> LessThan(x, 1) x <= 1 >>> StrictLessThan(x, 1) x < 1 Notes ===== There are a couple of "gotchas" to be aware of when using Python's operators. The first is that what your write is not always what you get: >>> 1 < x x > 1 Due to the order that Python parses a statement, it may not immediately find two objects comparable. When "1 < x" is evaluated, Python recognizes that the number 1 is a native number and that x is *not*. Because a native Python number does not know how to compare itself with a SymPy object Python will try the reflective operation, "x > 1" and that is the form that gets evaluated, hence returned. If the order of the statement is important (for visual output to the console, perhaps), one can work around this annoyance in a couple ways: (1) "sympify" the literal before comparison >>> S(1) < x 1 < x (2) use one of the wrappers or less succinct methods described above >>> Lt(1, x) 1 < x >>> Relational(1, x, "<") 1 < x The second gotcha involves writing equality tests between relationals when one or both sides of the test involve a literal relational: >>> e = x < 1; e x < 1 >>> e == e # neither side is a literal True >>> e == x < 1 # expecting True, too False >>> e != x < 1 # expecting False x < 1 >>> x < 1 != x < 1 # expecting False or the same thing as before Traceback (most recent call last): ... TypeError: cannot determine truth value of Relational The solution for this case is to wrap literal relationals in parentheses: >>> e == (x < 1) True >>> e != (x < 1) False >>> (x < 1) != (x < 1) False The third gotcha involves chained inequalities not involving '==' or '!='. Occasionally, one may be tempted to write: >>> e = x < y < z Traceback (most recent call last): ... TypeError: symbolic boolean expression has no truth value. Due to an implementation detail or decision of Python [1]_, there is no way for SymPy to create a chained inequality with that syntax so one must use And: >>> e = And(x < y, y < z) >>> type( e ) And >>> e (x < y) & (y < z) Although this can also be done with the '&' operator, it cannot be done with the 'and' operarator: >>> (x < y) & (y < z) (x < y) & (y < z) >>> (x < y) and (y < z) Traceback (most recent call last): ... TypeError: cannot determine truth value of Relational .. [1] This implementation detail is that Python provides no reliable method to determine that a chained inequality is being built. Chained comparison operators are evaluated pairwise, using "and" logic (see http://docs.python.org/2/reference/expressions.html#notin). This is done in an efficient way, so that each object being compared is only evaluated once and the comparison can short-circuit. For example, ``1 > 2 > 3`` is evaluated by Python as ``(1 > 2) and (2 > 3)``. The ``and`` operator coerces each side into a bool, returning the object itself when it short-circuits. The bool of the --Than operators will raise TypeError on purpose, because SymPy cannot determine the mathematical ordering of symbolic expressions. Thus, if we were to compute ``x > y > z``, with ``x``, ``y``, and ``z`` being Symbols, Python converts the statement (roughly) into these steps: (1) x > y > z (2) (x > y) and (y > z) (3) (GreaterThanObject) and (y > z) (4) (GreaterThanObject.__nonzero__()) and (y > z) (5) TypeError Because of the "and" added at step 2, the statement gets turned into a weak ternary statement, and the first object's __nonzero__ method will raise TypeError. Thus, creating a chained inequality is not possible. In Python, there is no way to override the ``and`` operator, or to control how it short circuits, so it is impossible to make something like ``x > y > z`` work. There was a PEP to change this, :pep:`335`, but it was officially closed in March, 2012. s>=cC st|j|ƒƒS(N(Rt__ge__(R.R/R0((s4lib/python2.7/site-packages/sympy/core/relational.pyR`‘s((RqRrRsRtR R¢R`(((s4lib/python2.7/site-packages/sympy/core/relational.pyR¬sàcB s,eZejZdZdZed„ƒZRS(s<=cC st|j|ƒƒS(N(Rt__le__(R.R/R0((s4lib/python2.7/site-packages/sympy/core/relational.pyR` s((RqRrRRsRtR R¢R`(((s4lib/python2.7/site-packages/sympy/core/relational.pyRšs cB s,eZejZdZdZed„ƒZRS(t>cC st|j|ƒƒS(N(Rt__gt__(R.R/R0((s4lib/python2.7/site-packages/sympy/core/relational.pyR`¯s((RqRrRRsRtR R¢R`(((s4lib/python2.7/site-packages/sympy/core/relational.pyR©s cB s,eZejZdZdZed„ƒZRS(ttnes>=tges<=tleR¬tgtR®tltN(*t __future__RRtaddRRtbasicRt compatibilityRtexprRtevalfRtsympifyRRzR R(R R t__all__R!RR RR RRR¥R¦R©RRRRRRRRR\R%(((s4lib/python2.7/site-packages/sympy/core/relational.pytsZ  ÿ$ÔF#ë