o 8VaE@sdZddlmZmZmZmZmZmZmZm Z m Z m Z ddl m Z ddlZddlZddlmZddlmZddlmZddlmZdd lmZdd lmZmZdd lmZmZd d Z dGddZ!ddZ"GdddZ#Gddde$Z%ddZ&ddZ'ddZ(ddZ)ddZ*d d!Z+d"d#Z,e,e Z-d$d%Z.d&d'Z/d(d)Z0d*d+Z1d,d-Z2d.d/Z3d0d1Z4d2d3Z5d4d5Z6d6d7Z7d8d9Z8d:d;Z9e2e1e5e6e3fZ:dd?ZGdEdFdFej?Z@dS)HzGTransform a string with Python-like source code into SymPy expression. ) generate_tokens untokenize TokenErrorNUMBERSTRINGNAMEOP ENDMARKER ERRORTOKENNEWLINE) iskeywordN)StringIO)AssumptionKeys)iterable)Basic)Symbol)arityFunction) filldedent func_namecCsFd|vrdSz td| WStyYnwt|dkr!dSdS)a 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 T) unicodedatalookupKeyErrorlen)tokenrrArBrrrrr4Rs   r4c@seZdZdZdS)ParenthesisGroupz9List of tokens representing an expression in parentheses.N)rCrDrErFrrrrrGosrGcCs6g}|D]}t|tr||q||q|Sr?)r"r4r=r>r<)r,Zresult2tokrrr_flattents   rIcfdd}|S)Nc sg}g}d}|D]l}|dtkre|ddkr"|tg|d7}nC|ddkre|d||}t|dkrA|d|n|dd}|||}|dg||dg} |t| |d8}q|ro|d|q||q|r{td|S)zsGroup tokens between parentheses with ParenthesisGroup. Also processes those tokens recursively. rrr(r)r'zMismatched parentheses)rr<rGpoprr=r) tokensr#r$r,Zstacks stacklevelrstackinnerZ parenGrouprecursorrr_inners8       z"_group_parentheses.._innerr)rQrRrrPr_group_parentheses~s (rScCszg}d}|D]4}|dtkr|}||qt|tr3|r-t|||r-t|||d<d}q||qd}||q|S)zConvert a NAME token + ParenthesisGroup into an AppliedFunction. Note that ParenthesisGroups, if not applied to any function, are converted back into lists of tokens. Nrr')rr<r"rGr&r4r=)rLr#r$r,symbolrHrrr_apply_functionss     rUcCsg}d}t||ddD]1\}}|||rd}q |dtkr1|ddkr1|dtkr1d}q t|trCt|trC|tdfq t|tro|dtkro|ddkro|jdd krg|d jdd f|d _|tdfq |dtkr|dd krt|tr|tdfq |dtkr|dd kr|dtkr|tdfq |d|dkrtkrnn|dd kr|ddkr|tdfq t|tr|dtkr|tdfq |dtkrt|||s|dtkr|ddkr|tdfq |dtkrt|||s|dtkrt|||s|tdfq |dtkr?t|||s?t|ts8|dtkr?|tdfq |rJ||d |S) aImplicitly 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*r(rr'rr))zipr<rrr"r4r6r&)rLr#r$r,skiprHnextTokrrr_implicit_multiplications $                 r[c Csg}d}d}d}t||ddD]\}}|||dtkr<|dtttfvr>> 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 FrrNr\Trrr)r(rWr')rXrrr&r<r=) rLr#r$r,r8Zconsuming_exponentlevelrHrZrrrfunction_exponentiation>sH $  88        r`crJ)a2Creates 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 sg}d}d}|D]}|rd}qd}|dtkr |ddvr d}n|r|dtkr|ddd}|r|dd}|dd=d} | t|kr|| } | |vsS| |vr^|td| fgn\| r| g} t| dt|D]} || s|| d8} n| || qnd | } |td ftd ftd | ftd fgn| t|kr|nd} |t| ftd ftd | ftd fg| d7} | t|ksGd}d}qd}||q|S)NFrr)rrTr'z%sNumberr(z'%s'r)r)rrr=isdigitranger<joinr) rLr#r$r,splitZsplit_previousrHrTtok_typer2charZuse predicaterr_split_symbolssV       z,split_symbols_custom.._split_symbolsr)rkrlrrjrsplit_symbols_customrs 8rmcC,ttttfD]}||||}qt|}|S)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 )rSimplicit_multiplicationrUr[rIr,r#r$steprrrrorocCrn)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) )rSimplicit_applicationrUr^rIrprrrrsrrrscCs"ttttfD]}||||}q|S)anAllows 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_symbolsrorsr`rprrr#implicit_multiplication_applications ruc Csg}d}|dt||ddD]\}}|\}}|\} } |tkr|} | dvsVt| sV|dtkr8|ddksV|dtkrL|ddvrL| tkrL| dksV| |vr^|| dur^|t| fq| |vr|dt| | d krwt| || <nt | || <|t| fq| |vr|| } t | t t t fst| r|t| fq|t| d krd nd ftd fttt| ftd fgn|||f||f}q|S) zAInserts calls to ``Symbol``/``Function`` for undefined variables.)NNrN)TrueFalseNonerrV)r(,=r(rrr))r<rXrr r setdefaultsetaddrrr"rrtyper!r=reprstr) rLr#r$r,ZprevTokrHrZtokNumtokValZ nextTokNumZ nextTokValr+objrrr auto_symbolsd         rc Cs g}d}|d\}}t|}|tkr|dkr|dks&|dkr-|ddtkr-|||S|dkr}|tdftdftdftd ftd fg|dd D]1\}} |tkr[| d kr[d } d }|si|tkri| dvritd|rt|d|| fqK|d|| fqK|S|||S)zSubstitutes "lambda" with its Sympy equivalent Lambda(). However, the conversion doesn't take place if only "lambda" is passed because that is a syntax error. FrlambdarZLambdar(r)N:ryT)rWr\z)Starred arguments in lambda not supportedr'ra)rrr r=rrinsert) rLr#r$r,flagr0r1ZtokLenrrrrrlambda_notationOs8    rcCsg}d}|D]@\}}|tkr#|}|dkr|d7}qd}|t|fq|dkr-td|}n|dkr7td|}n|dkr=td}|||fq|S)z'Allows standard notation for factorial.r!rZ factorialrZ factorial2)r r<rr3r)rLr#r$r,Z nfactorialr0r1oprrrfactorial_notationws$    rcCsTg}|D]#\}}|tkr |dkr|tdfq|||fq|||fq|S)z-Treats XOR, ``^``, as exponentiation, ``**``.r]r\)rr<)rLr#r$r,r0r1rrr convert_xors rcCsg}dd}g}|D]G\}}|tkr\|s-d|vr-d|vr-d|vr-|||fnj||r?t|dkr?|||fnX||rYt|dkrY||dd rY|||fn>g}n;|tkr|d krrt|d krr|t|fn%|d krt|dkr|t|fn|dkr|s|td fng}ng}|||f|rR|dd d krR|d t| }|dd d\}} |dd } t|dkr| |dd 7} |dd}| dd} | dd} dt| } dd| | fD\} } |pd} | pdd| }}| dt| | }}tdftdftdft| ftdftdftdftdft|ftdft|ftdftdftdftdft|ftdft|ftdftdfg}||g}q |S)zw Allows 0.2[1] notation to represent the repeated decimal 0.2111... (19/90) Run this before auto_number. cSstdd|DS)Ncss|]}|dvVqdS)Z 0123456789_Nr).0r2rrr sz6repeated_decimals..is_digit..)all)srrris_digitsz#repeated_decimals..is_digitrVejrrr'r[]z0.Nrrrb0cSsg|]}|dqS)r)lstrip)rwrrr sz%repeated_decimals..19r(Integerr)+Rationalry) rlowerr<rrrgreplacerr=)rLr#r$r,rZnumr0r1ZpreZpostZrepetendZzerosZ repetendsabcdrseqrrrrepeated_decimalss~ $        rc Csg}|D]j\}}|tkrg|}g}|ds|dr(|dd}tdftdfg}d|vs>d|vs4d |vrQ|d sQ|d sQtd ftd fttt|ftdfg}ntdftd ft|ftdfg}|||q|||fq|S)z Converts numeric literals to use SymPy equivalents. Complex numbers use ``I``, integer literals use ``Integer``, and float literals use ``Float``. rJNr'rWIrVrE0xZ0XFloatr(r)r) rendswithrr startswithrrr=r<) rLr#r$r,r0r1ZnumberZpostfixrrrr auto_numbers0    rcCstg}d}|D]1\}}|tkr|dkrd}d}|||fq|dkr0|tkr0d}|t|fq|||fq|S)z=Converts floats into ``Rational``. Run AFTER ``auto_number``.FrTr)rr<rr)rLr#r$r,Z passed_floatr0r1rrr rationalizes rcCs~g}tdf|vr;|tdf|tdft|D]\}}|tdfkr,|tdfq||q|tdf|S|}|S)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` won't 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. rzZEqr(ryr))rr<rr*)rLr#r$r,r/rrrr_transform_equals_sign.s   rcCrn)as 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` won't 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) )rSconvert_equals_signsrUrrIrprrrrKsrc CsVg}t|}t|jD]\}}}}}|||fq |D]} | |||}qt|S)zt Converts the string ``s`` to Python code, in ``local_dict`` Generally, ``parse_expr`` should be used. )r striprreadliner<r) rr#r$transformationsrLZ input_coder0r1rZ transformrrrstringify_exprws rcCst|||}|S)zn Evaluate Python code generated by ``stringify_expr``. Generally, ``parse_expr`` should be used. )eval)coder#r$exprrrr eval_exprsrTc Cs6|duri}n t|tstd|duri}td|n t|ts%td|p(d}|rRt|s3td|D]}t|sEttdt|t|dkrQttd q5t ||||}|sct t |d d }zt |||}| ddD]}d||<qp|WSty} z| ddD]}d||<q| td |d} ~ ww) aeConverts the string ``s`` to a SymPy expression, in ``local_dict`` 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, optional 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!``). 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=0) >>> a == b False >>> a.args (1, x) >>> b.args (x, 1) See Also ======== stringify_expr, eval_expr, standard_transformations, implicit_multiplication_application Nz!expecting local_dict to be a dictzfrom sympy import *z"expecting global_dict to be a dictrz0`transformations` should be a list of functions.zY expected a function in `transformations`, not %srzc a transformation should be function that takes 3 argumentszrz-Error from parse_expr with transformed code: )r"dict TypeErrorexecrr!rrrrcompile evaluateFalserrK Exception ValueError) rr#rr$evaluaterrZrvr2rrrr parse_exprsJF        rcCs2t|}t|}t|jdj}t|S)zO Replaces operators with the SymPy equivalent and sets evaluate=False. r)astparseEvaluateFalseTransformervisitZ ExpressionbodyvalueZfix_missing_locations)rnoderrrrs   rc@s\eZdZejdejdejdejdejdej dej dej diZ dZ dd Zd d Zd d ZdS)rAddMulPowZOrZAndZNot)#ZAbsZimresignarg conjugateZacosZacotZacscZasecZasinZatanZacoshZacothZacschZasechZasinhZatanhZcosZcotZcscZsecZsinZtanZcoshZcothZcschZsechZsinhZtanhZexpZlnlogZsqrtZcbrtcCslg}|D]/}t|tjr.|j}t|tjr|j}|j|kr(|||j|q||q||q|Sr?) r"rCallr%idr=flattenr7r<)r:r7r%r,rZarg_funcrrrr%s     z EvaluateFalseTransformer.flattenc Cs|jj|jvr|j|jj}||j}||j}d}t|jtjrNtj tj dt dtj t tdd|gtjdtjdt ddgddd }njt|jtjrt|jtj r||}}d }tj tj d t d|tj t tddgtjdtjdt ddgddd }n*tj tj d t d|tj t tddgtjdtjdt ddgddd }|r||}}tj tj |t d||gtjdtjdt ddgddd }|d vr||j||_|S|S) NFr)rctxr)roperandrrrrr)r%r7keywordsZstarargskwargsTr)rr)r __class__ operatorsrrightleftr"rSubrNameLoadZUnaryOpZUSubZNumkeyword NameConstantDivrr7)r:rZ sympy_classrrZrevnew_noderrr visit_BinOp4sX    z$EvaluateFalseTransformer.visit_BinOpcCsN||}t|jtjr%|jj|jvr%|jtj dtj dt dd|S)NrFrr) Z generic_visitr"r%rrr functionsrr<rrr)r:rrrrr visit_Callhs $z#EvaluateFalseTransformer.visit_CallN)rCrDrErrZMultrrrZBitOrZBitAndZBitXorrrrrrrrrrrs   4rr?)ArFtokenizerrrrrrrr r r rr rrior Zsympy.assumptions.askrZsympy.core.compatibilityrZsympy.core.basicrZ sympy.corerZsympy.core.functionrrZsympy.utilities.miscrrrr&r3r4listrGrIrSrUr[r^r`rmrtrorsrurrrrrrrrrZstandard_transformationsrrrrZNodeTransformerrrrrrs^0         ,H34W3(["(  q