*h8 v%SrSSKJr SSKJrJrJrJrJrJ r J r J r J r J r SSKJr SSKrSSKrSSKJr SSKrSSKrSSKJrJr SSKJr SS KJr SS KJr SS KJ r SS K!J"r" SS K#J$r$ SSK%J&r&J'r' Sr(\)\*\+4r,\-\+\4r.\\/\,\.\./\/\,4r0S8Sjr1S9S:Sjjr2S;Sjr3"SS\/\,5r4"SS5r5SSjr8S?Sjr9S?Sjr:S@Sjr;SASjr<\<"\15r=SBSjr>SBSjr?SCS jr@S@S!jrAS@S"jrBS@S#jrCS@S$jrDS@S%jrES@S&jrFS@S'jrGS@S(jrHSBS)jrI\B\A\E\F\C4rJS*\KS+'SDS,jrLSES-jrMS\JSS.4SFS/jjrNSGS0jrO"S1S2\R5rQ\B\A\E\F\C\@\D\?\>\I\;\GS3. rRS4RS5\RR555rU"S6S75rV\V"5rWg)HzGTransform a string with Python-like source code into SymPy expression. ) annotations) generate_tokens untokenize TokenErrorNUMBERSTRINGNAMEOP ENDMARKER ERRORTOKENNEWLINE) iskeywordN)StringIO)AnyCallable)reduce)AssumptionKeys)Basic)Symbol)Function func_name)MaxMincSU;ag[R"SU-5(+$![a [U5S:s$f=f)z Predicate for whether a token name can be split into multiple tokens. A token is splittable if it does not contain an underscore character and it is not the name of a Greek letter. This is used to implicitly convert expressions like 'xyz' into 'x*y*z'. _FzGREEK SMALL LETTER ) unicodedatalookupKeyErrorlen) token_names W/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/parsing/sympy_parser.py_token_splittabler%sL j#%%&;j&HIII #:""#s'AAcURUS5nU(dURUS5n[U5=(a [U[5(+$)z Predicate for whether a token name represents a callable function. Essentially wraps ``callable``, but looks up the token name in the locals and globals. r)getcallable isinstancer)token local_dict global_dict nextTokenfuncs r$_token_callabler/-sD >>%( #D uQx( D> :*T6":::cU/:Xd USSS:Xa [5e[U4[S4/n[S4/nSn[U5n[ USSS25HrupgUupXV- S- n U S:XaUS- nO U S:XaUS-nUS:XdM/U S- S:a*XS- S[:XaUSU S- U-XS- S-U-s $USU U-XS-U-s $ U$)Nr()r)rr r r" enumerate) nameresult beginningenddifflengthindexr*toknumtokvalis r$_add_factorial_tokensr@:s |vbz!}+lCy)I 9+C D [F!&2,/  NQ  S= AID s] AID 191uzfUmA.$6fq1u~ 1Fq56NBSHHbqzI-r :S@@0 Mr0c\rSrSrSrSrg)ParenthesisGroupVz9List of tokens representing an expression in parentheses.N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rDr0r$rBrBVsCr0rBc<\rSrSrSrS S SjjrS SjrSrSrSr g) AppliedFunction[zz A group of tokens representing a function and its arguments. `exponent` is for handling the shorthand sin^2, ln^2, etc. NcDUc/nXlX lX0l/SQUlg)Nfunctionargsexponent)rPrQrRitems)selfrPrQrRs r$__init__AppliedFunction.__init__as#  H   5 r0c4UR/URQ$)z1Return a list of tokens representing the function)rPrQrTs r$expandAppliedFunction.expandis * **r0c2[XRU5$N)getattrrS)rTr<s r$ __getitem__AppliedFunction.__getitem__mstZZ.//r0c\SUR<SUR<SUR<S3$)NzAppliedFunction(z, r4rOrXs r$__repr__AppliedFunction.__repr__ps 04 tyy04 ? ?r0)rQrRrPrSr\)rPTOKENrQrB)return list[TOKEN]) rErFrGrHrIrUrYr^rarJrDr0r$rLrL[s 6+0?r0rLc/nUHJn[U[5(a!URUR55 M9UR U5 ML U$r\)r)rLextendrYappend)r7result2toks r$_flattenrkusCG c? + + NN3::< ( NN3   Nr0c^SU4SjjnU$)Nc4>/n/nSnUHnUS[:XaUSS:Xa UR[/55 US- nOUSS:XaUSRU5 UR5n[ U5S:aUSR U5 O9USSnT "UUU5nUS/U-US/-n UR[U 55 US-nMU(aUSRU5 MURU5 M U(a [ S5eU$)zcGroup tokens between parentheses with ParenthesisGroup. Also processes those tokens recursively. rrr3r4r2zMismatched parentheses)r rhrBpopr"rgr) tokensr+r,r7stacks stacklevelr*stackinner parenGrouprecursors r$_inner"_group_parentheses.._inners' 24)+ EQx2~8s?MM"22"67!OJ1X_2J%%e,"JJLE6{Qr ))%0!&a  ()3)4!6',AhZ%%759+%E  &6z&BC!OJr !!%( e$78 56 6 r0rorer+DICTr,ryrD)rurvs` r$_group_parenthesesrzs'P Mr0c./nSnUHn[U[5(a=U(a#[XAU5(a[XE5US'SnMBUR U5 MUUS[ :XaUnUR U5 MwSnUR U5 M U$)zConvert a NAME token + ParenthesisGroup into an AppliedFunction. Note that ParenthesisGroups, if not applied to any function, are converted back into lists of tokens. Nr2r)r)rBr/rLrgr rh)ror+r,r7symbolrjs r$_apply_functionsr}s-/F F c+ , ,/&kJJ,V9r  c" Vt^F MM# F MM#  Mr0c/nSn[XSS5GHMupVURU5 U(aSnM"US[:XaUSS:XaUS[:XaSnMI[ U[ 5(a[ U[ 5(aUR[S45 MU[S4:XaBUR SS :XaUR SS 4UlUR[S45 MUS[:XaUR[S45 GMGMU[S 4:Xa[ U[ 5(aUR[S45 GM?US[:XaUR[S45 GMfU[S4:XaUR[S45 GMGMUS[:XdGM[XQU5(aGM[ U[ 5(dUS[:Xa+[XaU5(aUR[S45 GMU[S4:XaUR[S45 GM&US[:XdGM6UR[S45 GMP U(aURUS 5 U$) arImplicitly adds '*' tokens. Cases: - Two AppliedFunctions next to each other ("sin(x)cos(x)") - AppliedFunction next to an open parenthesis ("sin x (cos x + 1)") - A close parenthesis next to an AppliedFunction ("(x+2)sin x") - A close parenthesis next to an open parenthesis ("(x+2)(x+3)") - AppliedFunction next to an implicitly applied function ("sin(x)cos x") FrNr.T*r3rrr4r2)ziprhr r r)rLrPr/)ror+r,r7skiprjnextToks r$_implicit_multiplicationrs -/F DF12J/  c D  q6RCL r3i(t# r3i($r3ig77MM2s),QZ4'MM2s),S )MM2s),*Q4(U(Ug77QZ4'OGQ\,],]MM2s),S )MM2s),QZ4'MM2s),S0T fRj! Mr0c/nSnSnSn[XSS5GHupxURU5 US[:XaIUS[[[ 4;a1[ XqX(5(aUR[S45 US- nMkMmUS[:Xa-US[:Xa USS:Xa[ XqU5(aSnMMU(a[U[5(dUS[:Xa\USS:XaPUS[:Xa USS:Xd7US[:Xa USS:XdUR[S45 US- nSnGM&GM)GM,GM/U(dGM9US[:XaUSS ;aSnGMTU(aUS-nGMcUR[S 45 US-nGM U(aURUS 5 U(aUR[S 4/U-5 U$) z+Adds parentheses as needed after functions.rFrNr3**Tr)^rrr4r2) rrhr r r r r/r)rLrg) ror+r,r7 appendParenr exponentSkiprjrs r$_implicit_applicationrs,.FK DLF12J/  c FdNwqz"i1IIs EE r3i(q F!fnr!1gajD6Hs <<# =  300FbLSVs]  b(WQZ3->"1:+ c0A r3i0#q( #(L .? &3L[qzRGAJ2B$B  MM2s) $ 1 KC0F fRj! CykK/0 Mr0c6/n/nSnSn[XSS5GHJupxUS[:Xa*US[:XaUSS:Xa[XqU5(aSnOU(aUS[:XaUSS:Xa[S4nUR U5 USUSs=:Xa [:XaO OUSS :Xa USS :XaSnUSUSs=:Xa [:XaO OUSS :XaUSS :XaSnUS MU(a^U(dWUS[:XaUSS :XaUS- nOUSS :XaUS-nUS:Xa'UR U5 UR U5 /nGM9UR U5 GMM U(aUR US 5 U(aUR U5 U$) aPAllows functions to be exponentiated, e.g. ``cos**2(x)``. Examples ======== >>> from sympy.parsing.sympy_parser import (parse_expr, ... standard_transformations, function_exponentiation) >>> transformations = standard_transformations + (function_exponentiation,) >>> parse_expr('sin**4(x)', transformations=transformations) sin(x)**4 FrrNrTrrr4r3rr2)rr r r/rhrg) ror+r,r7rRconsuming_exponentlevelrjrs r$function_exponentiationr8sFH EF12J/  q6T>gajB.71:3Es <<%)" 1v~#a&J"6X& OOC 1v)r)c!fm c@Q%*"1v)r)c!fm c@Q%*"RL  01v|q6S=QJEVs]QJEz c" h' c90: fRj! h Mr0c^SU4SjjnU$)aCreates a transformation that splits symbol names. ``predicate`` should return True if the symbol name is to be split. For instance, to retain the default behavior but avoid splitting certain symbol names, a predicate like this would work: >>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable, ... standard_transformations, implicit_multiplication, ... split_symbols_custom) >>> def can_split(symbol): ... if symbol not in ('list', 'of', 'unsplittable', 'names'): ... return _token_splittable(symbol) ... return False ... >>> transformation = split_symbols_custom(can_split) >>> parse_expr('unsplittable', transformations=standard_transformations + ... (transformation, implicit_multiplication)) unsplittable c>/nSnSnUGHnU(aSnMSnUS[:Xa USS;aSnGOU(GayUS[:XGakUSSSnT "U5(GaSUSSnUSS2 Sn U [U5:Ga-Xyn X;dX;aUR[SU -45 OU R5(aU /n [ U S-[U55H4n XyR5(dU S-n OU RXy5 M6 S R U 5n UR [S 4[S 4[S U -4[S 4/5 OCU [U5:XaUOSn UR [U 4[S 4[S U -4[S 4/5 U S- n U [U5:aGM-SnSnGMSnURU5 GM U$)NFrr)rrTr2z%srNumberr3z'%s'r4r)r r"rhisdigitrangejoinrgr )ror+r,r7splitsplit_previousrjr|tok_typer?charcharsuse predicates r$_split_symbols,split_symbols_custom.._split_symbolss C$ N1v~#a&,B"B3q6T>Q"V$$%bz!}Hrs Ac&k/%y-1D"MM4*=>!\\^^%)FE%*1q5#f+%>'-y'8'8':':$%FA$) % VY 7 &? $&775>D"MMD(+;b#Y,0&4-+@2s)+MN/03v;.>(HC"MMD#;S ,0&4-+@2s)+MNQ%c&k/,"E%)N"E MM# _b r0rxrD)rrs` r$split_symbols_customrls,6p r0cx[[5"XU5n[X1U5n[XAU5n[ U5nU$)aMakes the multiplication operator optional in most cases. Use this before :func:`implicit_application`, otherwise expressions like ``sin 2x`` will be parsed as ``x * sin(2)`` rather than ``sin(2*x)``. Examples ======== >>> from sympy.parsing.sympy_parser import (parse_expr, ... standard_transformations, implicit_multiplication) >>> transformations = standard_transformations + (implicit_multiplication,) >>> parse_expr('3 x y', transformations=transformations) 3*x*y )rzimplicit_multiplicationr}rrkror+r,res1res2res3r7s r$rrs<" 5 6v; WD Dk :D #Dk BD d^F Mr0cx[[5"XU5n[X1U5n[XAU5n[ U5nU$)aMakes parentheses optional in some cases for function calls. Use this after :func:`implicit_multiplication`, otherwise expressions like ``sin 2x`` will be parsed as ``x * sin(2)`` rather than ``sin(2*x)``. Examples ======== >>> from sympy.parsing.sympy_parser import (parse_expr, ... standard_transformations, implicit_application) >>> transformations = standard_transformations + (implicit_application,) >>> parse_expr('cot z + csc z', transformations=transformations) cot(z) + csc(z) )rzimplicit_applicationr}rrkrs r$rrs<" 2 3F TD Dk :D ; ?D d^F Mr0cR[[[[4H nU"XU5nM U$)a6Allows a slightly relaxed syntax. - Parentheses for single-argument method calls are optional. - Multiplication is implicit. - Symbol names can be split (i.e. spaces are not needed between symbols). - Functions can be exponentiated. Examples ======== >>> from sympy.parsing.sympy_parser import (parse_expr, ... standard_transformations, implicit_multiplication_application) >>> parse_expr("10sin**2 x**2 + 3xyz + tan theta", ... transformations=(standard_transformations + ... (implicit_multiplication_application,))) 3*x*y*z + 10*sin(x**2)**2 + tan(theta) ) split_symbolsrrr)r7r+r,steps r$#implicit_multiplication_applicationrs10 7%'>@f+6@ Mr0c /nSnURS5 [XSS5GHupVUupxUupU[:XGaUn U S;d\[U 5(dLUS[:Xa USS:Xd6US[:XaUSS;aU [:XaU S:XdX;a$X[ LaUR[U 45 MX;ahUR [ [55RU 5 U S :Xa[U 5X'O [U 5X'UR[U 45 GMX;aNX+n [U [[[45(d[U 5(aUR[U 45 GMVUR![U S :waS OS 4[S 4[[#[%U 554[S 4/5 OURXx45 Xx4nGM U$) zAInserts calls to ``Symbol``/``Function`` for undefined variables.)r2rrN)TrueFalseNonerr)r3,=r3rrr4)rhrr rr null setdefaultsetaddrrr)rrtyper(rgreprstr) ror+r,r7prevTokrjrtokNumtokVal nextTokNum nextTokValr6objs r$ auto_symbolrsFG MM(F12J/ !( T>D11  b(WQZ3-> b(WQZ:-E&",s1B)j.>d.J tTl+#%%dCE266t<$'/~J$'-d|J$ tTl+$!'cNE4#@AAXc]]MM4,/ MM:#4x*ES tCI'S   MM6* +"Q0T Mr0c0/nSnUSupV[U5nU[:XaUS:XaUS:XdUS:Xa#USS[:XaURU5 U$US:aUR[S4[S4[S4[S 4[S 4/5 USS HjupU[:Xa U S :XaS n S nU(dU[:XaU S;a [ S5eU(aUR SX45 MWUR SX45 Ml U$URU5 U$)zSubstitutes "lambda" with its SymPy equivalent Lambda(). However, the conversion does not take place if only "lambda" is passed because that is a syntax error. FrlambdarLambdar3r4N:rT)rrz)Starred arguments in lambda not supportedr2r)r"r r rgr rinsert) ror+r,r7flagr=r>tokLenrrs r$lambda_notationrHs% F DAYNF [F ~&H, Q;&A+&)A,'*A MM& !, M+aZ MMx S S S S  #)*Rops r$factorial_notationrpsFJ  Rs r$ convert_xorrsVF  R<} r4j) v./ MM6* +! Mr0c/nSn/nUGHupgU[:XaU(dASU;a;SUR5;a'SUR5;aURXg45 OU"U5(aD[U5S:Xd"[U5S:Xa&U"USS5(aURXg45 O/nOU[:XaUS :Xa'[U5S:XaUR[U45 OWUS :Xa'[U5S:aUR[U45 O*US:XaU(dUR[S 45 O/nO/nURXg45 U(dGMVUSSS :XdGMeUS [U5*nUS SR S5upUSSn [U5S:Xa XSS- n UR SS5nU R SS5n U R SS5n S[U 5-n X4V s/sHoRS5PM sn upU=(d SnU =(d SSU -nnU S[U 5-U -nn[S4[S4[S4[U4[S4[S4[S4[S4[U4[S4[U4[S4[S4[S4[S4[U4[S4[U4[S4[S4/nURU5 /nGM U$s sn f)zk Allows 0.2[1] notation to represent the repeated decimal 0.2111... (19/90) Run this before auto_number. c&[SU55$)Nc3*# UH oS;v M g7f) 0123456789_NrD).0r?s r$ 6repeated_decimals..is_digit..s1q! %qs)all)ss r$is_digit#repeated_decimals..is_digits1q111r0rejrrr2r[]z0.Nrrr019r3Integerr4+Rationalr) rlowerrhr"r rreplacelstripr rg)ror+r,r7rnumr=r>prepostrepetendzerosw repetendsabcdrseqs r$repeated_decimalsrsF2C  V C6Mc.G6<<>) F+,&!!s3x1}HMhs2wqz&:&: F+, r\}SQ B<(33s8q= B<(3s FD>*C v&' 33r71:$Jc#hY'FAq ,IC1vayH3x1}F1I%++c2&C<<R(D''R0HD ME7;6FG6Fxx}6FGOD sA;3e qAs3x=0E9qAS 9%I II:&I S  II:&I S  IS )C, MM# CK!N MAHsK6c /nUHupEU[:XaUn/nURS5(aUSSn[S4[S4/nSU;d"SU;dSU;aGUR S 5(d1[S 4[S 4[[ [ U554[S 4/nO[S 4[S 4[U4[S 4/nURX-5 MURXE45 M U$)z Converts numeric literals to use SymPy equivalents. Complex numbers use ``I``, integer literals use ``Integer``, and float literals use ``Float``. )rJNr2rIrrE)0x0XFloatr3r4r) rendswithr r startswithrrrgrh) ror+r,r7r=r>numberpostfixrs r$ auto_numberrsF  V FGz**9tSk2f}#-3&=**<88gS T#f+./"c<i(2s)F6$&(#Y0 MM#- ( MM6* +'!* Mr0c/nSnUHjupVU[:XaUS:XaSnSnURXV45 M-US:Xa%U[:XaSnUR[U45 MXURXV45 Ml U$)z=Converts floats into ``Rational``. Run AFTER ``auto_number``.FrTr)r rhrr)ror+r,r7 passed_floatr=r>s r$ rationalizers{FL  T> # # MM6* + T !f&6 L MM66* + MM6* +! Mr0c2/n[S4U;aUR[S45 UR[S45 UH9nU[S4:XaUR[S45 M(URU5 M; UR[S45 U$UnU$)aTransforms the equals sign ``=`` to instances of Eq. This is a helper function for ``convert_equals_signs``. Works with expressions containing one equals sign and no nesting. Expressions like ``(1=2)=False`` will not work with this and should be used with ``convert_equals_signs``. Examples: 1=2 to Eq(1,2) 1*2=x to Eq(1*2, x) This does not deal with function arguments yet. rEqr3rr4)r rhr )ror+r,r7r*s r$_transform_equals_signr 'sF CyF tTl# r3i ES ! r3i( MM%   r3i  M Mr0cx[[5"XU5n[X1U5n[XAU5n[ U5nU$)a*Transforms all the equals signs ``=`` to instances of Eq. Parses the equals signs in the expression and replaces them with appropriate Eq instances. Also works with nested equals signs. Does not yet play well with function arguments. For example, the expression ``(x=y)`` is ambiguous and can be interpreted as x being an argument to a function and ``convert_equals_signs`` will not work for this. See also ======== convert_equality_operators Examples ======== >>> from sympy.parsing.sympy_parser import (parse_expr, ... standard_transformations, convert_equals_signs) >>> parse_expr("1*2=x", transformations=( ... standard_transformations + (convert_equals_signs,))) Eq(2, x) >>> parse_expr("(1*2=x)=False", transformations=( ... standard_transformations + (convert_equals_signs,))) Eq(Eq(2, x), False) )rzconvert_equals_signsr}r rkrs r$r r Ds<: 2 3F TD Dk :D !$K @D d^F Mr0tuple[TRANS, ...]standard_transformationsc/n[UR55n[UR5Hupg nUR Xg45 M UH n U "XAU5nM [ U5$)zh Converts the string ``s`` to Python code, in ``local_dict`` Generally, ``parse_expr`` should be used. )rstriprreadlinerhr) rr+r,transformationsro input_coder=r>r transforms r$stringify_exprrpslF!'')$J#2:3F3F#G1a v&'$H% 6{;% f r0c[XU5nU$)zb Evaluate Python code generated by ``stringify_expr``. Generally, ``parse_expr`` should be used. )eval)coder+r,exprs r$ eval_exprrs  : 'D Kr0Tc|Uc0nO5[U[5(d [S5e[U;a [ S5eUcn0n[ SU5 [ [5nUR5H*upg[U[R5(dM&XsU'M, [US'[US'O [U[5(d [S5eU=(d Sn[U[5(a+US :Xa [SSnOUS :Xa [SS nO [ S 5eUn[XX85n U(d[![#U 5S S5n [%XU5n UR'[S5H n [X'M U $![(a:n UR'[S5H n [X'M U [ SU <35eSn A ff=f)a Converts the string ``s`` to a SymPy expression, in ``local_dict``. .. warning:: Note that this function uses ``eval``, and thus shouldn't be used on unsanitized input. Parameters ========== s : str The string to parse. local_dict : dict, optional A dictionary of local variables to use when parsing. global_dict : dict, optional A dictionary of global variables. By default, this is initialized with ``from sympy import *``; provide this parameter to override this behavior (for instance, to parse ``"Q & S"``). transformations : tuple or str A tuple of transformation functions used to modify the tokens of the parsed expression before evaluation. The default transformations convert numeric literals into their SymPy equivalents, convert undefined variables into SymPy symbols, and allow the use of standard mathematical factorial notation (e.g. ``x!``). Selection via string is available (see below). evaluate : bool, optional When False, the order of the arguments will remain as they were in the string and automatic simplification that would normally occur is suppressed. (see examples) Examples ======== >>> from sympy.parsing.sympy_parser import parse_expr >>> parse_expr("1/2") 1/2 >>> type(_) >>> from sympy.parsing.sympy_parser import standard_transformations,\ ... implicit_multiplication_application >>> transformations = (standard_transformations + ... (implicit_multiplication_application,)) >>> parse_expr("2x", transformations=transformations) 2*x When evaluate=False, some automatic simplifications will not occur: >>> parse_expr("2**3"), parse_expr("2**3", evaluate=False) (8, 2**3) In addition the order of the arguments will not be made canonical. This feature allows one to tell exactly how the expression was entered: >>> a = parse_expr('1 + x', evaluate=False) >>> b = parse_expr('x + 1', evaluate=False) >>> a == b False >>> a.args (1, x) >>> b.args (x, 1) Note, however, that when these expressions are printed they will appear the same: >>> assert str(a) == str(b) As a convenience, transformations can be seen by printing ``transformations``: >>> from sympy.parsing.sympy_parser import transformations >>> print(transformations) 0: lambda_notation 1: auto_symbol 2: repeated_decimals 3: auto_number 4: factorial_notation 5: implicit_multiplication_application 6: convert_xor 7: implicit_application 8: implicit_multiplication 9: convert_equals_signs 10: function_exponentiation 11: rationalize The ``T`` object provides a way to select these transformations: >>> from sympy.parsing.sympy_parser import T If you print it, you will see the same list as shown above. >>> str(T) == str(transformations) True Standard slicing will return a tuple of transformations: >>> T[:5] == standard_transformations True So ``T`` can be used to specify the parsing transformations: >>> parse_expr("2x", transformations=T[:5]) Traceback (most recent call last): ... SyntaxError: invalid syntax >>> parse_expr("2x", transformations=T[:6]) 2*x >>> parse_expr('.3', transformations=T[3, 11]) 3/10 >>> parse_expr('.3x', transformations=T[:]) 3*x/10 As a further convenience, strings 'implicit' and 'all' can be used to select 0-5 and all the transformations, respectively. >>> parse_expr('.3x', transformations='all') 3*x/10 See Also ======== stringify_expr, eval_expr, standard_transformations, implicit_multiplication_application Nz!expecting local_dict to be a dictzcannot use "" in local_dictzfrom sympy import *maxminz"expecting global_dict to be a dictrDrimplicitz!unknown transformation group namezrz-Error from parse_expr with transformed code: )r)dict TypeErrorr ValueErrorexecvarsbuiltinsrStypesBuiltinFunctionTyperrrTrcompile evaluateFalserrn Exception) rr+rr,evaluate builtins_dictr6r_transformationsrrvr?rs r$ parse_exprr0sJ  D ) );<<  677  "K0X &,,.ID#u8899$'D!/! E E  T * *<==%+O/3'' e # t   * !u @A A* ! GD }T*J? Z t 5b)A JM* Zb)A JM*Z"OPTx XYY Zs2E77 F;5F66F;c[R"U5n[5RU5n[R"UR SR 5n[R"U5$)zG Replaces operators with the SymPy equivalent and sets evaluate=False. r)astparseEvaluateFalseTransformervisit Expressionbodyvaluefix_missing_locations)rnodetransformed_nodes r$r*r*EsX 99Q&D&DE  $ $%5 66r0c\rSrSr\R S\R S\RS\RS\RS\RS\RS\RS0r Sr\RS \R S \R"S \R$S \R&S \R(S0rSrSrSrSrSrg)r4iQAddMulPowOrAndNot)#Absimresignarg conjugateacosacotacscasecasinatanacoshacothacschasechasinhatanhcoscotcscsecsintancoshcothcschsechsinhtanhexplnlogsqrtcbrtNeLtLeGtGer c ^U4Sjn[U[URUR5/UR45up4[ U5S:XaUS$[ R"[ R"TR[ R[ R"5S9U[ R"S[ R"SS9S9/S 9$) Nc >Uup#UupEURTR;a [S5e[R"[R "TRUR[R "5S9TRU5TRU5/[R"S[R"SS9S9/S9nX&/-U4$)Nz3Only equation or inequality operators are supportedidctxr,Fr8rGr8r.rQkeywords) __class__relational_operatorsr"r2CallNameLoadr5keywordConstant)accop_rightr7leftrrightnewrTs r$reducer7EvaluateFalseTransformer.visit_Compare..reducernsLF IB||4#<#<< !VWW((XX00>CHHJjj& 5(9:++*CLLu5( (r0rrrmr,Frprqrr)rrops comparatorsr}r"r2rvrw operatorsBitAndrxryrz)rTr:rrQrs` r$ visit_Compare&EvaluateFalseTransformer.visit_Comparems ) S4#3#34r499o  t9>7NxxT^^CJJ7SXXZHkkj 58QRS  r0c/nUHn[U[R5(aURn[U[R5(a URnURU:Xa-UR UR URU55 MURU5 MURU5 M U$r\) r)r2rvr.rnrgflattenrQrh)rTrQr.r7rGarg_funcs r$r EvaluateFalseTransformer.flattensC#sxx((88h11'}}H;;$&MM$,,sxx">?MM#& c" r0c URRUR;GaMURURRnURUR5nURUR 5nSn[ UR[R5(a[R"[R"S[R"5S9[R"[R"5[R"S5S9U/[R"S[R"SS9S9/S 9nGO[ UR[R 5(Gaj[ UR [R5(aX4p4S n[R"[R"S [R"5S9U[R"[R"5[R"S5S9/[R"S[R"SS9S9/S 9nO[R"[R"S [R"5S9U[R"[R"5[R"S5S9/[R"S[R"SS9S9/S 9nU(aX4p4[R"[R"U[R"5S9XC/[R"S[R"SS9S9/S 9nUS ;a!UR#UR$U5UlU$U$) NFr>rmr)roperandr,rprqrrTr?)r=r>)rrtrr5r~r}r)r2SubrvrwrxUnaryOpUSubrzryDivrrQ)rTr: sympy_classr~r}revnew_nodes r$ visit_BinOp$EvaluateFalseTransformer.visit_BinOps7 77   ...):):;KJJtzz*E::dii(DC$''377++U ;++S\\!_MuU!kkj SX@YZ[ DGGSWW--dii55"'%C88U ; sxxz3<>> from sympy.parsing.sympy_parser import T, standard_transformations >>> assert T[:5] == standard_transformations c,[[5Ulgr\)r"_transformationNrXs r$rU _T.__init__s_%r0c[$r\)rrXs r$__str__ _T.__str__sr0c[U5[LaU4n/nUHn[U5[La)UR[ UR 5U5 M>[U5[ La2UR[ URUR 565 M[S5e [UVs/sH n[UPM sn5$s snf)Nzunexpected slice arg) rtupleintrhrrslicergindicesr!r)rTtr?tirs r$r^_T.__getitem__sAw%A BBx3tvvr*+bU" 466 234 677 !4!Qoa(!4554s2C )rN) rErFrGrHrIrUrr^rJrDr0r$rrs& 6r0r)r#rrdboolr\)r*rcr+ryr,ry)r6rr7rerdre)r7list[TOKEN | AppliedFunction])ruTRANS)rozlist[TOKEN | ParenthesisGroup]r+ryr,ry)rorr+ryr,ryrx)rzCallable[[str], bool])rorer+ryr,ryrdre)r7rer+ryr,ryrdre) rrr+ryr,ryrr rdr)r+ryr,ry)rrr+ DICT | Nonerztuple[TRANS, ...] | strr,r)rr)XrI __future__rtokenizerrrrrr r r r r ryrr2riorr%r&typingrr functoolsrsympy.assumptions.askrsympy.core.basicr sympy.corersympy.core.functionrsympy.utilities.miscr(sympy.functions.elementary.miscellaneousrrrrrrrcr rylistrr%r/r@rBrLrkrzr}rrrrrrrrrrrrrrrr r r__annotations__rrr0r*NodeTransformerr4rrrSrrr(rDr0r$rsEM">>>  0"(*=  c3h CH~$u+tT*DK78 # ;8 tE{ ??4)X2>B0f1hNn%%67 )-2=0&*/:059>I>0f%P6 UpD&:!&*!/:!P %6 + */2&26-*.tZ 7tZ(tZn 7us22ur& ))]_EZEZE\]]668Dr0