\h2SSKJr SSKJrJr SSKJr SSKJr SSK J r SSK J r SSK Jr SS KJr SS KJrJr SS KJr SS KJrJrJrJr SS KJrJr SSKJr SSK J!r! SSK"J#r# Sr$SSK%J&r& SSK'J(r( SSK)J*r* SSK+J,r, Sr-Sr.Sr/"SS\\ 5r0\0r1"SS\05r2\2r3"SS\05r4\4r5"SS \05r6"S!S"\65r7"S#S$\65r8"S%S&\75r9\9r:"S'S(\85r;\;r<"S)S*\75r=\=r>"S+S,\85r?\?r@\2\2\2\4\4\4\9\9\;\;\=\=\?\?S-.\0lAS.rB\("\&\&5S/5rC\("\\5S05rD\("\*\&5S15rD\("\*\ 5S25rD\("\*\,5S35rD\("\*\*5S45rDSs r0_canonical_coeffrI1s --C    2 2 cggt $ $|| 77    .DA ^^T^ *FA 77Q;/C1u||  ** 88C r2c\rSrSr%SrSr0rS\S'SrSSjr \ S 5r \ S 5r \ S 5r \ S 5r\ S 5r\ S5r\ S5rSr\ S5rSSjrSrSrSrSSjrSr\ S5rSrg)r Aa Base class for all relation types. Explanation =========== 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.ValidRelationOperator. Examples ======== >>> 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 LU[La[R"XU40UD6$URR US5nUc[ SU-5e[ U[[45(d3[[[X455(a[[S55eU"X40UD6$)Nz&Invalid relational operator symbol: %rz A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. )r r__new__rMget ValueError issubclassrranymapr1 TypeErrorr)clsr@r>rop assumptionss r0rORelational.__new__s j ==3>+> >''++C6 ;EKL L#Bx(( 3|cZ011 ,! 3+{++r2c URS$)z#The left-hand side of the relation.r_argsselfs r0r@Relational.lhszz!}r2c URS$)z$The right-hand side of the relation.rr[r]s r0r>Relational.rhsr`r2c [[[[[[[[[[[ [ 0nUR up#[RURURUR5X25$)zReturn 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 ) rrrrrrargsr rOrPrD)r^opsarFs r0rARelational.reversedsS$2r2r2r2r2r2>yy!!#''$))TYY"?FFr2c lURup[U[5(d[U[5(d{[[[[ [ [[ [[[ [[0n[RURURUR5U*U*5$U$)zReturn 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 ) rdr.rrrrrrrr rOrPrD)r^rfrFres r0 reversedsignRelational.reversedsignsw$yy1k**jK.H.Hr2r2r2r2r2rBC%%cggdii&CaR!L LKr2c [[[[[[ [ [[[[[0n[ R"URUR5/URQ76$)aReturn 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. ) rrrrrrr rOrPrDrd)r^res r0negatedRelational.negatedsK62r2r2r2r2r2> !!#''$))"4AtyyAAr2cU$)zreturn the non-strict version of the inequality or self EXAMPLES ======== >>> from sympy.abc import x >>> (x < 1).weak x <= 1 >>> _.weak x <= 1 rLr]s r0weakRelational.weak  r2cU$)zreturn the strict version of the inequality or self EXAMPLES ======== >>> from sympy.abc import x >>> (x <= 1).strict x < 1 >>> _.strict x < 1 rLr]s r0strictRelational.strict"rqr2c|UR"URVs/sHo"RU5PM sn6$s snfr-)rDrd_evalf)r^precss r0 _eval_evalfRelational._eval_evalf1s-yy499=9a88D>9=>>=s9c [URVs/sH&n[U[5(a UROUPM( sn5nX R:wa'UR "U6n[U[5(dU$OUnUR R(a]UR R(aAURR(a&URUR :a URnOLURR(a URnO$[[U55U:wa URn[URSS5n[UR SS5n[UR[5(d[UR [5(aU$U(aU"5(a UR$UR R(d\U(aUU"5(aI[URUR */5upgXcR:waURR$U$s snf)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)tuplerdr.r r5rDr> is_number is_Numberr@rArgetattrrri)r^irdr8LHS_CEMSRHS_CEMSexpr1_s r0r5Relational.canonical4s8tyyYy!Z:%>%>akkAEyYZ 99  4 Aa,,-A 55??uu155??quuquu}JJ UU__ A 74= !T ) A155"> !X(** v/HE~zz...EZs-I c [U[5(GaXUR4;agXpCUR[[ 4;dUR[[ 4;aURUR:wag[ URUR5VVs/sHupVURUUS9PM snnupxUSLaU$USLaU$[ URURR5VVs/sHupVURXbS9PM snnupU SLaU $U SLaU $XxX4n [SU 55(agU H nUS;dM Us $ gURUR:wa URnURUR:wagURRURUS9nUSLagURRURUS9nUSLagUSLaU$U$gs snnfs snnf)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(# UHoSLv M g7f)FNrL.0rs r0 $Relational.equals..s-1aEz1s)TFN) r.r rArDrrziprdequalsallr@r>) r^otherrrfrFrjleftrightlrrles r0rRelational.equalsts eZ ( (t}}--qvv"b!QVVBx%766QVV# ,/qvvqvv+>@+>41 !xx;M ( O+>@ 4< LD=K&)!&&!**//&BD&Bda((1(L&BD:I:I")-1--- A - 66QVV# A66QVV# uu||AEE7I$K5=  QUU8J%LE> 4< L S )@Ds G8:G>c  SSKJn SSKJn UnUR"UR Vs/sHoUR "S0UD6PM sn6nUR(Gal[URU5(a[URU5(dU$URUR- nSnUR(a~URS5n[SUR555(aGUR5Vs/sHoURS5PM snupU[R U --nO&UR#S5(a[R$nUb*URR'U[R$5nUR(n[+[-SUR.55n [1U 5S:XaSSKJn U R75n URUR- nU "Xl5upU R8S La@U R:(aUR U*U - U 5nGOUR X*U - 5nGOsUR U[R$5nGOQ[1U 5S:GaASSKJn SS K!J"n [+[QU 55n URUR- nU "U/U Q76n U S nU S U"U 5nU Vs/sHnUU- PM n n[+[-S[+[SX5555nUR8S LaUS:wa5U"UVVs/sH unnUU-PM snn6nUR UU*U- 5nOgUSSUSS-nUS U"UVVs/sH unnUU-PM snn6nUR UU*5nO!UR U[R$5nUR(nUSnU"U5USU"U5-:aU$U$s snfs snf![<a SS KJ n SS K!J"nJ#nJ$n U"UW 5nURK5nUS nSUS 'U"U5nUVs/sHnUU- PM Os snfnnUR URMUU 5RO5U*U- 5nN!Ua Nf=ff=fs snfs snnfs snnf![<a Nf=f)NrAddr'c3># UHoRS:Hv M g7f)rN)_precrs r0r,Relational._eval_simplify..s>-=ww!|-=srcURSL$NF)is_real)xs r0+Relational._eval_simplify..s %)?r2 linear_coeffsF)PolynomialError)gcdPolypoly)rcUSS:g$NrrL)fs r0rrs ! r2measureratiorL)*addrexprr(rDrdsimplifyr=r.r@r> is_comparablenrS as_real_imagr ImaginaryUnitrZero_eval_relationr5listfilter free_symbolslensympy.solvers.solvesetrpopis_zero is_negativerQsympy.polys.polyerrorsrsympy.polys.polytoolsrrr all_coeffs from_listas_exprrr)r^kwargsrr(r8rdifvrvivfreerrrHrFrrrrpcconstantscalectmpmtmpnzmrnewexprlhstermrs r0_eval_simplifyRelational._eval_simplifys%  FF166:6aZZ)&)6: ; ???aeeT***QUUD2I2I%%!%%-CA  EE!H>Q^^-=>>>.1.>.>.@A.@cc!f.@AFBQ__R//AAFF}FF))!QVV4 A?PQD4yA~D A%%!%%-C(0DAyyE)==!"rAvq 1A !q"q& 1AFF1aff-TaD9 .D%%!%%-C%c1D1A uH"FE234!$!A4v&94A ;MNOC}}-#q=&)c+BcdaAEc+B&CG !w E0A BA'*!fQi#a&)&;G #A&)c+BcdaAEc+B&CG !w 9AFF8QVV4 KK# 1:w'$-7 7HKi;B2" FEE  aLLLN#$R5 !" #A678adTE\a88FF4>>!Q#7#?#?#AH9uCTU* 05 ,C ,C "sO3O8 A/O=<O= O=AR6R%+AR61R* R6R6:R0 R6% R6=R"/RQ)r^optsrs r0_eval_trigsimpRelational._eval_trigsimps24yy$((3d3Xdhh5O$5OPPr2c N^U4SjUR5nUR"U6$)Nc3F># UHoR"S0TD6v M g7fNrL)expand)rargrs r0r$Relational.expand..s:  $V$ s!)rdrD)r^rrds ` r0rRelational.expands : :yy$r2c4^[[U4Sj55e)Nc>ST3$)Nz,cannot determine truth value of Relational: rLr]sr0r%Relational.__bool__.. s FtfMr2)rUrr]s`r0__bool__Relational.__bool__s M   r2cSSKJn SSKJn URn[ U5S:XdeUR 5nU"XSS9nU$![a U"X@[R5nU$f=f)Nr)solve_univariate_inequality) ConditionSetrF) relational) sympy.solvers.inequalitiesrsympy.sets.conditionsetrrrrNotImplementedErrorr Reals)r^rrsymsrxsets r0 _eval_as_setRelational._eval_as_set snJ8  4yA~~ HHJ 2.t5ID  # 2 1D  2sA!A)(A)c[5$r-)setr]s r0binary_symbolsRelational.binary_symbolss u r2r-)F)returnbool)__name__ __module__ __qualname____firstlineno____doc__ __slots__rM__annotations__r=rOpropertyr@r>rArirlrorsryr5rrrrrrr__static_attributes__rLr2r0r r AsPbI@B=BM ,8GG*0BBB    ?==~.`XtQ   r2r ct^\rSrSrSrSrSrSrSr\ S5r S Sjr \ S 5r U4S jrS rS rSrU=r$)r!i%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. ==rLTc URS[R5n[U5n[U5nU(a [ X5nUcU"XSS9$[U5$[ R XU5$NevaluateFr )rrr r is_eqr rOrVr@r>optionsr vals r0rOEquality.__new__qsf;;z+<+E+EFsmsm /C{3e44}$!!#C00r2c[X:H5$r-r rVr@r>s r0rEquality._eval_relation~ ##r2c [SSSSS9 SSKJnJn US:XaU$US:XaU$U(aX- $UR U5UR U*5-nUcU"U6$UR U5$) a 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^LRr rrrrds r0_eval_rewrite_as_AddEquality._eval_rewrite_as_Adds6 "# &,'7  / 6H 6H 5L}}Q#--"33  #T* *~~d##r2c.[RUR;d[RUR;aPURR (a UR1$UR R (a UR 1$[5$r-r truerdfalser@ is_Symbolr>rr]s r0rEquality.binary_symbolsZ 66TYY !''TYY"6xx!!z!##z!u r2c >[T U]"S 0UD6n[U[5(dU$SSKJn [UR U5(a[URU5(dU$URn[U5S:XaSSK J n SSK J n UR5nU"U"UR UR*SS9U5upURSLaUR!Xy*U- 5n OUR!X-U *5n USn U "U 5US U "U5-::aU nUR$$UR$$!["a UR$$f=f) Nrr'rrrFr rrrL)superrr.r!rr(r@r>rrrrrrrrrDrQr5) r^rrr(rrrrrHrFenewr __class__s r0rEquality._eval_simplifys/ G " ,V ,!X&&H!%%&&j.E.EH   t9> $@HHJ$v6;99%66!R!V,D66!%!,D +4=F7Ogaj$@@A{{q{{ {{ sBD66 E Ec&SSKJn U"U/UQ70UD6$)z-See the integrate function in sympy.integralsr) integrate)sympy.integrals.integralsr/)r^rdrr/s r0r/Equality.integrates7////r2cTURUR- R"U0UD6$)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 r0r3Equality.as_polys'488#,,d=f==r2)T)rrrrrrel_opr is_EqualityrO classmethodrr rrrr/r3r __classcell__)r,s@r0r!r!%sbDJFIK 1$$2$h60 > >r2r!cL\rSrSrSrSrSrSr\S5r \ S5r Sr Sr g ) r"iaAn 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. !=rLc [U5n[U5nURS[R5nU(a [ X5nUcU"XSS9$[U5$[ R "XU40UD6$r )r rrr is_neqr rOr s r0rOUnequality.__new__slsmsm;;z+<+E+EF "C{3e44}$!!#C;7;;r2c[X:g5$r-rrs r0rUnequality._eval_relation"rr2c.[RUR;d[RUR;aPURR (a UR1$UR R (a UR 1$[5$r-r#r]s r0rUnequality.binary_symbols&r(r2c [UR6R"S0UD6n[U[5(aUR"UR6$UR $r)r!rdrr.rDrl)r^reqs r0rUnequality._eval_simplify/sH tyy ! 0 0 :6 : b( # #99bgg& &zzr2N)rrrrrr6rrOr8rrrrrrLr2r0r"r"sF@FI <$$r2r"c2\rSrSrSrSrSr\S5rSr g) _Inequalityi;zInternal base class for all *Than types. Each subclass must implement _eval_relation to provide the method for comparing two real numbers. rLc [U5n[U5nURS[R 5nU(aXX4H>nUR SLa[SU-5eU[RLdM5[S5e UR"X40UD6$[R"XU40UD6$![a [s$f=f)Nr Fz!Invalid comparison of non-real %szInvalid NaN comparison) r rNotImplementedrrr is_extended_realrUr NaNrr rO)rVr@r>rr mes r0rO_Inequality.__new__Ds "3-C3-C;;z+<+E+EF j&&%/#$G"$LMM;#$<== !%%c:': :!!#C;7;;+ "! ! "sB//CCc NURX5nUcU"XSS9$[U5$)NFr )_eval_fuzzy_relationr )rVr@r>rrs r0r_Inequality._eval_relation`s.&&s0 ;s%0 0C= r2N) rrrrrrrOr8rrrLr2r0rGrG;s' I<8!!r2rGc<\rSrSrSrSr\S5r\S5rSr g)_GreateriizNot intended for general use _Greater is only used so that GreaterThan and StrictGreaterThan may subclass it for the .gts and .lts properties. rLc URS$rr[r]s r0gts _Greater.gtsrzz!}r2c URS$Nrr[r]s r0lts _Greater.ltsvrVr2N rrrrrrrrTrYrrLr2r0rRrRi4 I r2rRc<\rSrSrSrSr\S5r\S5rSr g)_Lessi{zNot intended for general use. _Less is only used so that LessThan and StrictLessThan may subclass it for the .gts and .lts properties. rLc URS$rXr[r]s r0rT _Less.gtsrVr2c URS$rr[r]s r0rY _Less.ltsrVr2Nr[rLr2r0r^r^{r\r2r^c@\rSrSrSrSrSr\S5r\ S5r Sr g)r&iaClass 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. rL>=c[X5$r-is_gers r0rO GreaterThan._eval_fuzzy_relations Sr2c&[UR6$r-)rrdr]s r0rsGreaterThan.strictw499~r2N) rrrrrrr6r8rOrrsrrLr2r0r&r&s;`BI Fr2r&cT\rSrSr\R rSrSr\S5r \ S5r Sr g)r$i~rL<=c[X5$r-)is_lers r0rOLessThan._eval_fuzzy_relationrir2c&[UR6$r-)rrdr]s r0rsLessThan.strictrlr2N) rrrrr&rrr6r8rOrrsrrLr2r0r$r$~s=!!GI Fr2r$cT\rSrSr\R rSrSr\S5r \ S5r Sr g)r%irL>c[X5$r-)is_gtrs r0rO&StrictGreaterThan._eval_fuzzy_relationrir2c&[UR6$r-)rrdr]s r0roStrictGreaterThan.weakrlr2N rrrrr&rrr6r8rOrrorrLr2r0r%r%=!!GI Fr2r%cT\rSrSr\R rSrSr\S5r \ S5r Sr g)r#irLnerdgernlerugtr~ltcUR(a9UR(a'X- RS5nUR(aU$ggg)z{Return (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)rfrFrs r0_n2rs;  1??ummA   J +r2cgr-rLr@r>s r0 _eval_is_ger r2cgr-rLrs r0 _eval_is_eqrrr2cgrrLrs r0rrs r2cgr-rLrs r0rrrr2cgr-rLrs r0rrrr2cj[U5[U5:wag[S[X555$)NFc3N# UHup[[X55v M g7fr-)rr )rrxos r0r_eval_is_eq..sGZa ,,s#%)rrrrs r0rrs* 3x3s8 GSG GGr2Nc,[[XU55$)z_Fuzzy bool for lhs is strictly less than rhs. See the docstring for :func:`~.is_ge` for more. )rrgr@r>rXs r0rr U3[1 22r2c,[[XU55$)zbFuzzy bool for lhs is strictly greater than rhs. See the docstring for :func:`~.is_ge` for more. )rrprs r0rwrwrr2c[XU5$)zbFuzzy bool for lhs is less than or equal to rhs. See the docstring for :func:`~.is_ge` for more. rfrs r0rprps ; ''r2c^SSKJnJn [U[5(a[U[5(d [ S5e[ X5nUbU$[X5nUb4U[R[R4;a [U5nUS:$U"X5nU"X5nUR(a}UR(akUR(aUR(d"UR(aUR(agX- n U [R LaU"X5n U bU $gggg)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.wrapperrrr.r(rUrrr InfinityNegativeInfinityfloatrJ is_infiniteis_extended_positiveis_extended_negativerK) r@r>rXrrretvaln2_lhs_rhsdiffrs r0rgrg szV sD ! !jd&;&;ABB  "F  ] >ajj!"4"4552Y7N!#3!#3  T%:%:  T%>%>DDTDTY]YrYr9D155 ,T?>I"! &; r2c,[[XU55$)zXFuzzy bool for lhs does not equal rhs. See the docstring for :func:`~.is_eq` for more. )rr rs r0r=r=rr2cV ^^"^#^$^%X4X44H&up4[USS5nUcMU"U5nUcM$Us $ [X5nUbU$[[U5[U55[[U5[U55:wa[X5nUbU$X:Xag[ SX455(agUR (d4UR (d#[ U[5[ U[5:wagSSKJ nJ m%J m$ SS K J m" U"UT5nU"UT5n UR(dU R(Ga[URU R/5(ag[URU R/5(ag[URU R/5(a*[UR [#U R 5/5$[$R&m#U"U#UU$4S jn U "U5n U S(ddU "U5n U S(dR[)T""U S 6T""U S 6T5n [)T#T""U S 6-T#T""U S 6-T5n[[+[,X/55$SS KJn U"U5nU"U5nU[$R2:XaU[$R2:Xd[-[)UUT55$[ SX455(GaX- nU"UT5nUR4nUbUSLaUR6(agU(agUR95unnUR:(a1[=U5(aUR>SLagOUR@SLag[CX5nUb[EUS:H5$URG5unnSnU"UT5nU"UT5nUR4(a URHnOURJ(aUR(aSnOUR4SLavURnUcgSSK&J'n U"U[$RP5unnX4V s/sHn U RSUU5PM n!n U!X/:wa[-[)/U!QTP765nUSLaSnO,[UUU%4SjT"RWU555(aSnUbU$ggs sn f)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_EqNTc3B# UHn[U[5v M g7fr-)r.rrs r0ris_eq..s <AZ; ' 'Fr)rrrJrrcJ>UUU4Sjn[TRU5U5$)NcN>T"UT5(aS$T"TU-T5(aS$S$)NrealimagrL)tIrXrJs r0r0is_eq..split_real_imag..s:*1k::G*1Q3 <<GBFGr2)rr)r real_imagrrrXrJs r0split_real_imagis_eq..split_real_imag s#HI d+Y7 7r2rr)rc3B# UHn[U[5v M g7fr-)r.r(rs r0rr#s 3 1:a   r)clear_coefficientsc36># UHnT"UT5v M g7fr-rL)rrfrXrs r0rrRsG6FQ ,,6Fs),rrr)typerr&r.rrrrrJrrrrrrr rr rTr$sympy.functions.elementary.complexesrrKris_commutativerBis_Floatr is_integer is_rationalrr as_numer_denom is_nonzero is_finitesympy.simplify.simplifyrrsubsrSr)&r@r>rXside1side2 eval_funcrrrrrlhs_rirhs_rieq_realeq_imagrarglhsargrhsr_difzrrrrdr_n_drrGr8rrdrrrJrs& ` @@@@r0r r s*d SJ. E:t4  u%F! / "F  S 49%$s)T#Y)GGS&  M z <# < < <mms}}3 3  !'' c; /D c; /D 4+++ d&&(8(89 : : d++T-B-BC D D d++T-B-BC D Dd774C\C\9]^_ _ OO 8 8 !%d|$S)F$<VF^ 4c6&>6JKXC$8 8!c6&>>R:RT_` Z'1C!DEE<SS!%%FaeeOeFFK@A A 3 333i!#{3 LL =Ezd11!1 ::!}}<<5( )%' ] >B!G$ $!!#1  ; / ; / ::B \\~~u$^^:K-aI e4T>s0R&r-)K __future__rbasicrr coreerrorsrsortingrrr functionr numbersr singletonr sympifyr r parametersrlogicrrrrsympy.logic.boolalgrrsympy.utilities.iterablesrsympy.utilities.miscrsympy.utilities.exceptionsr__all__rr(sympy.multipledispatchr) containersr*symbolr+r1r:rIr rr!rr"rrGrRr^r&rr$rr%rr#rrMrrrrrwrprgr=r rLr2r0rs","+)>>4*+@  +&  ^*^BE>zE>PEEP+!*+!\{$K$l(l\ u    U               $ $  $ % % % % %HH33(xv3Hr2