wgddlmZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZmZdd lmZdd lmZmZmZmZdd lmZmZdd lmZddlmZddl m!Z!dZ"ddl#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*dZ+dZ,dZ-GddeeZ.e.Z/Gdde.Z0e0Z1Gdde.Z2e2Z3Gdde.Z4Gd d!e4Z5Gd"d#e4Z6Gd$d%e5Z7e7Z8Gd&d'e6Z9e9Z:Gd(d)e5Z;e;Z<Gd*d+e6Z=e=Z>e0e0e0e2e2e2e7e7e9e9e;e;e=e=d,e._?d-Z@e&e$e$d.ZAe&eed/ZBe&e(e$d0ZBe&e(e d1ZBe&e(e*d2ZBe&e(e(d3ZBd;d5ZCd;d6ZDd;d7ZEd;d8ZFd;d9ZGd;d:ZHy4)<) annotations)AtomBasic)ordered) EvalfMixin) AppliedUndef) int_valued)S)_sympify SympifyError)global_parameters) fuzzy_bool fuzzy_xor fuzzy_and fuzzy_not)Boolean BooleanAtom)sift) filldedent)sympy_deprecation_warning)RelEqNeLtLeGtGe RelationalEquality UnequalityStrictLessThanLessThanStrictGreaterThan GreaterThanExpr)dispatch)Tuple)SymbolcHt|txrt|t SN) isinstancerr)sides Z/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/core/relational.py _nontrivBoolr0s# dG $ &$% %&c|jtDcic]}||j}}|j|Scc}wr,)atomsr canonicalxreplace)condrrepss r/ _canonicalr9(s:$(JJz$: ;qAq{{N ;D ; ==  >> from sympy import Rel >>> from sympy.abc import x, y >>> Rel(y, x + x**2, '==') Eq(y, x**2 + x) A relation's type can be defined upon creation using ``rop``. The relation type of an existing expression can be obtained using its ``rel_op`` property. Here is a table of all the relation types, along with their ``rop`` and ``rel_op`` values: +---------------------+----------------------------+------------+ |Relation |``rop`` |``rel_op`` | +=====================+============================+============+ |``Equality`` |``==`` or ``eq`` or ``None``|``==`` | +---------------------+----------------------------+------------+ |``Unequality`` |``!=`` or ``ne`` |``!=`` | +---------------------+----------------------------+------------+ |``GreaterThan`` |``>=`` or ``ge`` |``>=`` | +---------------------+----------------------------+------------+ |``LessThan`` |``<=`` or ``le`` |``<=`` | +---------------------+----------------------------+------------+ |``StrictGreaterThan``|``>`` or ``gt`` |``>`` | +---------------------+----------------------------+------------+ |``StrictLessThan`` |``<`` or ``lt`` |``<`` | +---------------------+----------------------------+------------+ For example, setting ``rop`` to ``==`` produces an ``Equality`` relation, ``Eq()``. So does setting ``rop`` to ``eq``, or leaving ``rop`` unspecified. That is, the first three ``Rel()`` below all produce the same result. Using a ``rop`` from a different row in the table produces a different relation type. For example, the fourth ``Rel()`` below using ``lt`` for ``rop`` produces a ``StrictLessThan`` inequality: >>> from sympy import Rel >>> from sympy.abc import x, y >>> Rel(y, x + x**2, '==') Eq(y, x**2 + x) >>> Rel(y, x + x**2, 'eq') Eq(y, x**2 + x) >>> Rel(y, x + x**2) Eq(y, x**2 + x) >>> Rel(y, x + x**2, 'lt') y < x**2 + x To obtain the relation type of an existing expression, get its ``rel_op`` property. For example, ``rel_op`` is ``==`` for the ``Equality`` relation above, and ``<`` for the strict less than inequality above: >>> from sympy import Rel >>> from sympy.abc import x, y >>> my_equality = Rel(y, x + x**2, '==') >>> my_equality.rel_op '==' >>> my_inequality = Rel(y, x + x**2, 'lt') >>> my_inequality.rel_op '<' z"dict[str | None, type[Relational]]ValidRelationOperatorTNc 8|turtj|||fi|S|jj |d}|t d|zt |ttfs/ttt||frttd|||fi|S)Nz&Invalid relational operator symbol: %rz A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. )rr__new__rKget ValueError issubclassrranymapr0 TypeErrorr)clsr?r=rop assumptionss r/rMzRelational.__new__s j ==c3>+> >''++C6 ;EKL L#Bx( 3|c3Z01 ,! 3+{++r1c |jdS)z#The left-hand side of the relation.r_argsselfs r/r?zRelational.lhszz!}r1c |jdS)z$The right-hand side of the relation.rrXrZs r/r=zRelational.rhsr\r1c ttttttttttt t i}|j \}}tj|j|j|j||S)a1Return 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 ) rrrrrrargsrrMrNrC)r[opsarEs r/rBzRelational.reversedsW$2r2r2r2r2r2>yy1!!#''$))TYY"?AFFr1c Z|j\}}t|tst|ts{tttt t tt ttt tti}tj|j|j|j| | S|S)a=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 ) r_r-rrrrrrrrrMrNrC)r[rarEr`s r/ reversedsignzRelational.reversedsignss$yy11k*jK.Hr2r2r2r2r2rBC%%cggdii&CaR!L LKr1c tttttt t ttttti}t j|j|jg|jS)azReturn 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 existing ones as it will not be affected by the `evaluate` flag. ) rrrrrrrrMrNrCr_)r[r`s r/negatedzRelational.negatedsK62r2r2r2r2r2> !!#''$))"4AtyyAAr1c|S)zreturn the non-strict version of the inequality or self EXAMPLES ======== >>> from sympy.abc import x >>> (x < 1).weak x <= 1 >>> _.weak x <= 1 rJrZs r/weakzRelational.weak  r1c|S)zreturn the strict version of the inequality or self EXAMPLES ======== >>> from sympy.abc import x >>> (x <= 1).strict x < 1 >>> _.strict x < 1 rJrZs r/strictzRelational.strictrhr1cx|j|jDcgc]}|j|c}Scc}wr,)rCr__evalf)r[precss r/ _eval_evalfzRelational._eval_evalf.s-tyy499=a188D>=>>=s7c t|jDcgc] }t|tr |jn|"c}}||jk7r!|j |}t|ts|S|}|j jrR|j jr|jjrl|j|j kDrS|j}nF|jjr |j}n#tt||k7r |j}t|jdd}t|j dd}t|jtst|j tr|S|r|r |jS|j jsS|rQ|rJt|j|j g\}}||jk7r|jjS|Scc}w)aReturn a canonical form of the relational by putting a number on the rhs, canonically removing a sign or else ordering the args canonically. 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 >>> (-y < -x).canonical x < y The canonicalization is recursively applied: >>> from sympy import Eq >>> Eq(x < y, y > x).canonical True could_extract_minus_signN)tupler_r-rr4rCr= is_number is_Numberr?rBrgetattrrrc)r[ir_r7LHS_CEMSRHS_CEMSexpr1_s r/r4zRelational.canonical1ss8tyyY!Z:%>akkAEYZ 499  4 Aa,A 55??uu155??quuquu}JJ UU__ A 74= !T ) A155"> !X(* v/HE1~zz...EZs%Hct|tr|||jfvry||}}|jtt fvs|jtt fvr|j|jk7ryt |j|jDcgc]\}}|j||c}}\}}|dur|S|dur|St |j|jjDcgc]\}}|j||c}}\} } | dur| S| dur| S||| | f} td| Dry| D] }|dvs|cSy|j|jk7r |j}|j|jk7ry|jj|j|}|dury|jj|j|}|dury|dur|S|Sycc}}wcc}}w)zReturn 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.TF)failing_expressionc3$K|]}|du yw)FNrJ.0rvs r/ z$Relational.equals..s-aqEz-s)TFN) r-rrBrCrrzipr_equalsallr?r=) r[otherr|rarErvjleftrightlrrles r/rzRelational.equalsqs eZ (t}}--qAvv"b!QVVBx%766QVV# ,/qvvqvv+>@#'1a !xx;M ( O@ e4< LD=K&)!&&!**//&BD"a((19K(LDB:I:I5"b)-1-- !A - !66QVV# A66QVV# uu||AEE7I$K5=  QUU8J%LE> 4< L S )@Ds G*1G0c  ddlm}ddlm}|}|j|j Dcgc]}|j di|c}}|jr?t|j|rt|j|s|S|j|jz }d}|jrx|jd}td|jDrh|jDcgc]}|jdc}\}} |tj | zz}n!|j#drtj$}|*|jj'|tj$}|j(}t+t-d|j.} t1| dk(r ddlm} | j7} |j|jz }| || \} }| j8d ur:| j:r|j | | z | }n7|j | | | z }n |j |tj$}nEt1| dk\r6 ddlm} dd l!m"}t+tQ| } |j|jz }| |g| } | d }| d =|| }| Dcgc]}||z  } }t+t-dt+tS| | }|j8d urz|dk7r2||Dcgc] \}}||z c}}}|j || |z }nc|dd|ddz}|d=||Dcgc] \}}||z c}}}|j || }n |j |tj$}|j(}|d}|||d||zkr|S|Scc}wcc}w#t<$rdd lm }dd l!m"}m#}m$} || }|jK}|d }d|d <||}|Dcgc]}||z  ncc}w}}|j |jM|| jO| |z }n #|$rYnwxYwYwxYwcc}wcc}}wcc}}w#t<$rYwxYw)NrAddr&c3:K|]}|jdk(yw)rN)_precr~s r/rz,Relational._eval_simplify..s>qww!|>src|jduSNF)is_real)xs r/z+Relational._eval_simplify..s%)?r1 linear_coeffsF)PolynomialError)gcdPolypoly)rc|ddk7SNrrJ)fs r/rz+Relational._eval_simplify..s! r1measureratiorJ)*addrexprr'rCr_simplifyr<r-r?r= is_comparablenrQ as_real_imagr ImaginaryUnitrZero_eval_relationr4listfilter free_symbolslensympy.solvers.solvesetrpopis_zero is_negativerOsympy.polys.polyerrorsrsympy.polys.polytoolsrrr all_coeffs from_listas_exprrr)r[kwargsrr'r7rvdifvrvivfreerrrGrErrrrpcconstantscalectmpmtmpnzmrnewexprlhstermrs r/_eval_simplifyzRelational._eval_simplifys  AFF166:aZQZZ)&): ; ??aeeT**QUUD2I%%!%%-CA  EE!H>Q^^-=>>.1.>.>.@Aacc!fAFBQ__R//AAFF}FF))!QVV4 A?PQD4yA~D A%%!%%-C(a0DAqyyE)==!"rAvq 1A !q1"q& 1AFF1aff-TaD9 .D%%!%%-C%c1D1A uH"FE234$4A4v&94At ;MNOC}}-#q=&)c+BdaAE+B&CG !w E0A BA'*!fQi#a&)&;G #A&)c+BdaAE+B&CG !w 9AFF8QVV4 KK# 1:w'$-7 7HKi;B2" FEE  aLLLN#$R5 !" #A678dTE\888FF4>>!Q#7#?#?#AH9uCTU* 05 ,C ,C "sN>+O(B#OAQ<3 Q+?AQ<Q0 7Q< Q6 9Q<Q("/Q P.s:  $V$:s)r_rC)r[rr_s ` r/rzRelational.expands": :tyy$r1ctd)Nz*cannot determine truth value of Relational)rSrZs r/__bool__zRelational.__bool__sDEEr1cddlm}ddlm}|j}t |dk(sJ|j } |||d}|S#t$r|||tj}Y|SwxYw)Nr)solve_univariate_inequality) ConditionSetrF) relational) sympy.solvers.inequalitiesrsympy.sets.conditionsetrrrrNotImplementedErrorr Reals)r[rrsymsrxsets r/ _eval_as_setzRelational._eval_as_setsrJ8  4yA~~ HHJ 2.tQ5ID  # 2 41D  2s A!A,+A,ctSr,)setrZs r/binary_symbolszRelational.binary_symbolss u r1r,)F)__name__ __module__ __qualname____doc__ __slots__rK__annotations__r<rMpropertyr?r=rBrcrergrjror4rrrrrrrrJr1r/rr>sPbI@B=BM ,8GG*0BBB    ?==~.`XtQ F r1rcheZdZdZdZdZdZdZedZ d dZ e dZ fd Z d Zd ZxZS) r a An equal relation between two objects. Explanation =========== 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 ===== Python treats 1 and True (and 0 and False) as being equal; SymPy does not. And integer will always compare as unequal to a Boolean: >>> Eq(True, 1), True == 1 (False, True) 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)``. If ``eq = Eq(x, y)`` then write `eq.lhs - eq.rhs` to get ``x - y``. .. deprecated:: 1.5 ``Eq(expr)`` with a single argument is a shorthand for ``Eq(expr, 0)``, but this behavior is deprecated and will be removed in a future version of SymPy. ==rJTc |jdtj}t|}t|}|r$t ||}| |||dSt|St j |||SNevaluateFr)rrrr is_eqrrMrTr?r=optionsrvals r/rMzEquality.__new__jsl;;z+<+E+EFsmsm S/C{3e44}$!!#sC00r1ct||k(Sr,r rTr?r=s r/rzEquality._eval_relationws ##r1c tddddddlm}m}|dk(r|S|dk(r|S|r||z S|j ||j | z}|||S|j |S) ar return 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. If one side is 0, the non-zero side will be returned. .. deprecated:: 1.13 The method ``Eq.rewrite(Add)`` is deprecated. See :ref:`eq-rewrite-Add` for details. Examples ======== >>> from sympy import Eq, Add >>> from sympy.abc import b, x >>> eq = Eq(x + b, x - b) >>> eq.rewrite(Add) #doctest: +SKIP 2*b >>> eq.rewrite(Add, evaluate=None).args #doctest: +SKIP (b, b, x, -x) >>> eq.rewrite(Add, evaluate=False).args #doctest: +SKIP (b, x, b, -x) z Eq.rewrite(Add) is deprecated. For ``eq = Eq(a, b)`` use ``eq.lhs - eq.rhs`` to obtain ``a - b``. z1.13zeq-rewrite-Add)deprecated_since_versionactive_deprecations_target stacklevelr)_unevaluated_Addrr)rrrr make_args _from_args)r[LRrrrrr_s r/_eval_rewrite_as_AddzEquality._eval_rewrite_as_Add{s6 "# &,'7  / 6H 6H q5L}}Q#--"33  #T* *~~d##r1ctj|jvstj|jvrF|jj r |jhS|j j r |j hStSr,r truer_falser? is_Symbolr=rrZs r/rzEquality.binary_symbolsZ 66TYY !''TYY"6xx!!z!##z!u r1c t |d i|}t|ts|Sddlm}t|j |rt|j|s|S|j}t|dk(r ddl m }ddl m }|j}|||j |j d|\}} |jdur|j!|| |z } n|j!||z| } |d} | | |d | |zkr| }|j$S|j$S#t"$rY|j$SwxYw) Nrr&rrrFrrrrJ)superrr-r rr'r?r=rrrrrrrrrCrOr4) r[rrr'rrrrrGrEenewr __class__s r/rzEquality._eval_simplifys, G " ,V ,!X&H!%%&j.EH   t9> $@HHJ$v6;199%66!aR!V,D66!a%!,D +4=F7Ogaj$@@A{{q{{ {{ s2BD)) E?Ec&ddlm}||g|i|S)z-See the integrate function in sympy.integralsr) integrate)sympy.integrals.integralsr )r[r_rr s r/r zEquality.integrates7////r1cT|j|jz j|i|S)zReturns lhs-rhs as a Poly Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x**2, 1).as_poly(x) Poly(x**2 - 1, x, domain='ZZ') )r?r=as_poly)r[gensrs r/rzEquality.as_polys)-488#,,d=f==r1)T)rrrrrel_opr is_EqualityrM classmethodrrrrrr r __classcell__)r s@r/r r s]DJFIK 1$$2$h60 >r1r cDeZdZdZdZdZdZedZe dZ dZ y) r!aTAn unequal relation between two objects. Explanation =========== 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. !=rJc t|}t|}|jdtj}|r$t ||}| |||dSt|St j |||fi|Sr)r rrris_neqrrMrs r/rMzUnequality.__new__srsmsm;;z+<+E+EF c"C{3e44}$!!#sC;7;;r1ct||k7Sr,rrs r/rzUnequality._eval_relationrr1ctj|jvstj|jvrF|jj r |jhS|j j r |j hStSr,rrZs r/rzUnequality.binary_symbolsrr1c t|jjdi|}t|tr|j|jS|j Sr)r r_rr-rCre)r[reqs r/rzUnequality._eval_simplify(sI 0Xtyy ! 0 0 :6 : b( #499bgg& &zzr1N) rrrrrrrMrrrrrrJr1r/r!r!sF@FI <$$r1r!c*eZdZdZdZdZedZy) _InequalityzInternal base class for all *Than types. Each subclass must implement _eval_relation to provide the method for comparing two real numbers. rJc z t|}t|}|jdtj }|rV||fD];}|j durtd|z|tjus2td|j||fi|Stj|||fi|S#t$r tcYSwxYw)NrFz!Invalid comparison of non-real %szInvalid NaN comparison) r r NotImplementedrrris_extended_realrSr NaNrrrM)rTr?r=rrmes r/rMz_Inequality.__new__=s "3-C3-C;;z+<+E+EF Cj >&&%/#$G"$LMM;#$<==  >&3%%c3:': :!!#sC;7;;+ "! ! "sB((B:9B:c V|j||}| |||dSt|S)NFr)_eval_fuzzy_relationr )rTr?r=rrs r/rz_Inequality._eval_relationYs2&&sC0 ;sC%0 0C= r1N)rrrrrrMrrrJr1r/rr4s' I<8!!r1rc4eZdZdZdZedZedZy)_GreaterzNot intended for general use _Greater is only used so that GreaterThan and StrictGreaterThan may subclass it for the .gts and .lts properties. rJc |jdSrrXrZs r/gtsz _Greater.gtskzz!}r1c |jdSNrrXrZs r/ltsz _Greater.ltsor+r1Nrrrrrrr*r.rJr1r/r(r(b4 I r1r(c4eZdZdZdZedZedZy)_LesszNot intended for general use. _Less is only used so that LessThan and StrictLessThan may subclass it for the .gts and .lts properties. rJc |jdSr-rXrZs r/r*z _Less.gts}r+r1c |jdSrrXrZs r/r.z _Less.ltsr+r1Nr/rJr1r/r2r2tr0r1r2c8eZdZdZdZdZedZedZ y)r%aClass representations of inequalities. Explanation =========== 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 $\ge$ 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 $\ge$ rhs | +----------------------------+-----------------+ |LessThan(lhs, rhs) | lhs $\le$ 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 https://docs.python.org/3/reference/expressions.html#not-in). 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.__bool__()) 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 ``__bool__`` 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. rJ>=ct||Sr,is_gers r/r&z GreaterThan._eval_fuzzy_relationlS#r1c&t|jSr,)rr_rZs r/rjzGreaterThan.strictp499~r1N) rrrrrrrr&rrjrJr1r/r%r%s;`BI Fr1r%cLeZdZejZdZdZedZe dZ y)r#rJ<=ct||Sr,)is_lers r/r&zLessThan._eval_fuzzy_relation}r:r1c&t|jSr,)rr_rZs r/rjzLessThan.strictr<r1N) rrrr%rrrrr&rrjrJr1r/r#r#ws=!!GI Fr1r#cLeZdZejZdZdZedZe dZ y)r$rJ>ct||Sr,)is_gtrs r/r&z&StrictGreaterThan._eval_fuzzy_relationr:r1c&t|jSr,)rr_rZs r/rgzStrictGreaterThan.weakr<r1N rrrr%rrrrr&rrgrJr1r/r$r$=!!GI Fr1r$cLeZdZejZdZdZedZe dZ y)r"rJner6ger>lerCgtrJltc||jr0|jr#||z jd}|jr|Syyy)zReturn (a - b).evalf(2) if a and b are comparable, else None. This should only be used when a and b are already sympified. rN)revalf)rarErs r/_n2rUs=  1??1ummA   J +r1cyr,rJr?r=s r/ _eval_is_gerX r1cyr,rJrWs r/ _eval_is_eqr[rYr1cyrrJrWs r/r[r[s r1cyr,rJrWs r/r[r[rYr1cyr,rJrWs r/r[r[rYr1cjt|t|k7rytdt||DS)NFc3LK|]\}}tt||ywr,)rr)rrnos r/rz_eval_is_eq..sGAZa ,Gs"$)rrrrWs r/r[r[s, 3x3s8 GS#G GGr1Nc.tt|||S)zgFuzzy bool for lhs is strictly less than rhs. See the docstring for :func:`~.is_ge` for more. )rr9r?r=rVs r/rLrL U3[1 22r1c.tt|||S)zjFuzzy bool for lhs is strictly greater than rhs. See the docstring for :func:`~.is_ge` for more. )rr@rcs r/rErErdr1ct|||S)zjFuzzy bool for lhs is less than or equal to rhs. See the docstring for :func:`~.is_ge` for more. r8rcs r/r@r@s c; ''r1cddlm}m}t|trt|ts t dt ||}||St||}|2|tjtjfvr t|}|dk\S|||}|||}|jrd|jrW|jr |js|jr |jry||z } | tj ur|| |} | | Syyyy)a Fuzzy bool for *lhs* is greater than or equal to *rhs*. Parameters ========== lhs : Expr The left-hand side of the expression, must be sympified, and an instance of expression. Throws an exception if lhs is not an instance of expression. rhs : Expr The right-hand side of the expression, must be sympified and an instance of expression. Throws an exception if lhs is not an instance of expression. assumptions: Boolean, optional Assumptions taken to evaluate the inequality. Returns ======= ``True`` if *lhs* is greater than or equal to *rhs*, ``False`` if *lhs* is less than *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. The four comparison functions ``is_le``, ``is_lt``, ``is_ge``, and ``is_gt`` are each implemented in terms of ``is_ge`` in the following way: is_ge(x, y) := is_ge(x, y) is_le(x, y) := is_ge(y, x) is_lt(x, y) := fuzzy_not(is_ge(x, y)) is_gt(x, y) := fuzzy_not(is_ge(y, x)) Therefore, supporting new type with this function will ensure behavior for other three functions as well. To maintain these equivalences in fuzzy logic it is important that in cases where either x or y is non-real all comparisons will give None. Examples ======== >>> from sympy import S, Q >>> from sympy.core.relational import is_ge, is_le, is_gt, is_lt >>> from sympy.abc import x >>> is_ge(S(2), S(0)) True >>> is_ge(S(0), S(2)) False >>> is_le(S(0), S(2)) True >>> is_gt(S(0), S(2)) False >>> is_lt(S(2), S(0)) False Assumptions can be passed to evaluate the quality which is otherwise indeterminate. >>> print(is_ge(x, S(0))) None >>> is_ge(x, S(0), assumptions=Q.positive(x)) True New types can be supported by dispatching to ``_eval_is_ge``. >>> from sympy import Expr, sympify >>> from sympy.multipledispatch import dispatch >>> class MyExpr(Expr): ... def __new__(cls, arg): ... return super().__new__(cls, sympify(arg)) ... @property ... def value(self): ... return self.args[0] >>> @dispatch(MyExpr, MyExpr) ... def _eval_is_ge(a, b): ... return is_ge(a.value, b.value) >>> a = MyExpr(1) >>> b = MyExpr(2) >>> is_ge(b, a) True >>> is_le(a, b) True r)AssumptionsWrapperis_extended_nonnegativez'Can only compare inequalities with ExprNT)sympy.assumptions.wrapperrhrir-r'rSrXrUr InfinityNegativeInfinityfloatr" is_infiniteis_extended_positiveis_extended_negativer#) r?r=rVrhriretvaln2_lhs_rhsdiffrs r/r9r9szV sD !jd&;ABB c "F  c] >ajj!"4"4552Y7N!#{3!#{3  T%:%:  T%>%>DDTDTY]YrYr9D155 ,T;?>I"! &; r1c.tt|||S)z`Fuzzy bool for lhs does not equal rhs. See the docstring for :func:`~.is_eq` for more. )rrrcs r/rrrdr1cz"#$%||f||ffD]#\}}t|dd}|||}|!|cSt||}||Stt|t|tt|t|k7rt||}||S||k(ryt d||fDry|j s.|j s"t |tt |tk7ryddlm }m %m $dd l m "||}||} |js | jrft|j| jgryt|j| jgryt|j| jgr*t|j t#| j gSt$j&#"#$fd } | |} | ds`| |} | dsSt)"| d "| d } t)#"| d z#"| d z}tt+t,| |gSdd lm}||}||}|t$j2k(r|t$j2k(st-t)||St d||fDr||z }||}|j4}||dur |j6ry|ry|j9\}}|j:r)t=|r|j>dury|j@durytC||}|tE|dk(S|jG\}}d}||}||}|j4r |jH}n|jJr|jrd}n|j4dur|j}|ddl&m'}||t$jP\}}||fD cgc]} | jS||}!} |!||gk7rCt-t)g|!}|dur)d}n&tU%fd"jW|Drd}||Syycc} w)a 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 _eval_EqNTc3<K|]}t|tywr,)r-rr~s r/rzis_eq..s .split_real_imag..s1*1k:*1Q3 <BFr1)rr)r real_imagrrrVr"s r/split_real_imagzis_eq..split_real_imags#HI d+Y7 7r1r}r~)rc3<K|]}t|tywr,)r-r'r~s r/rzis_eq..s 31:a  3rz)clear_coefficientsc30K|] }|ywr,rJ)rrarVrns r/rzis_eq..KsGQ ,Gs),rur[r(typerrr-rrjrhrnr"rrrrrorr rrrRr$sympy.functions.elementary.complexesrr#ris_commutativer@is_Floatr is_integer is_rationalrUr as_numer_denom is_nonzero is_finitesympy.simplify.simplifyrrksubsrQr)&r?r=rVside1side2 eval_funcrqrhrsrtrlhs_rirhs_rieq_realeq_imagrarglhsargrhsr_difzrrrrrdr_n_drrFr7rzr_rrr"rns& ` @@@@r/rrs&dc S#J. uE:t4  u%F! c "F  S 49%$s)T#Y)GGS#&  M cz <#s < <mms}}3 3  !'' c; /D c; /D 4++ d&&(8(89 : d++T-B-BC D d++T-B-BC Dd774C\C\9]^_ _ OO 8 !%d|$S)F$<VF^ 4c6&>6JKXC$8 8!c6&>>R:RT_` Z'71C!DEE<SS!%%FaeeOeFFK@A A 3c 33Ci!#{3 LL =Ezd11!1 ::!}<<5( %' c] >B!G$ $!!#1  ; / ; / ::B \\~~u$^^:K-aI e4T>s P8r,)I __future__rbasicrrsortingrrTrfunctionr numbersr singletonr sympifyr r parametersrlogicrrrrsympy.logic.boolalgrrsympy.utilities.iterablesrsympy.utilities.miscrsympy.utilities.exceptionsr__all__rr'sympy.multipledispatchr( containersr)symbolr*r0r9rHrrr rr!rrr(r2r%rr#rr$rr"rrKrUrXr[rLrEr@r9rrrJr1r/rs""+)>>4*+@  +& Z*ZzE>zE>PEEP+!*+!\{$K$l(l\ u    U               $ $  $ % % % % %HH33(xv3Hr1