fume-manage-python.git

U  
P±dòÔã@sôdZdgZddlZddlZddlmZddlmZGdddeZGdd    d    eZ    Gd
ddeZ
Gdd d eZGdddeZ GdddeZefZeefZddZGdddeZddZGdddZddZddZddZd[d d!Zd\d"d#Zd]d$d%Zd^d'd(Zd)d*Zd_d+d,Z d-d.Z!d/d0Z"d1d2Z#d3d4Z$d5d6Z%d7d8Z&d9d:Z'd;d<Z(d=d>Z)d?d@Z*dAdBZ+dCdDZ,dEdFZ-dGdHZ.dIdJZ/e/Z0dKdLZ1dMdNZ2dOdPZ3dQdRZ4dSdTZ5ej6fdUdVZ7GdWdXdXZ8GdYdZdZZ9dS)`z{Fortran/C symbolic expressions
 
References:
- J3/21-007: Draft Fortran 202x. https://j3-fortran.org/doc/year/21/21-007.pdf
ÚExpréN)ÚEnum)Úgcdc@seZdZdZdZdZdZdS)ÚLanguagez2
    Used as Expr.tostring language argument.
    rééN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚPythonÚFortranÚC©rrúJd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/f2py/symbolic.pyrsrc@sLeZdZdZdZdZdZdZdZdZ    dZ
d    Zd
ZdZ dZd ZdZdZdZdS)ÚOpz$
    Used as Expr op attribute.
    é
ééééé(édéÈéÒéÜi,ièiÐi¸i¹N)rr    r
rÚINTEGERÚREALÚCOMPLEXÚSTRINGÚARRAYÚSYMBOLÚTERNARYÚAPPLYÚINDEXINGÚCONCATÚ
RELATIONALÚTERMSÚFACTORSÚREFÚDEREFrrrrr&s rc@sHeZdZdZdZdZdZdZdZdZ    e
ejfdd    Z ejfd
dZdS) ÚRelOpzH
    Used in Op.RELATIONAL expression to specify the function part.
    rréééécCsR|tjkr0tjtjtjtjtjtjd|     ¡Stjtjtjtjtjtjd|S)N)ú.eq.ú.ne.ú.lt.ú.le.ú.gt.ú.ge.)ú==ú!=ú<ú<=ú>ú>=)
rr r+ÚEQÚNEÚLTÚLEÚGTÚGEÚlower)ÚclsÚsÚlanguagerrrÚ
fromstringFs 
þþÿÿzRelOp.fromstringcCsb|tjkr6tjdtjdtjdtjdtjdtjdi|Stjdtjdtjd    tjd
tjdtjdi|S) Nr0r1r2r3r4r5r6r7r8r9r:r;)    rr r+r<r=r>r?r@rA©ÚselfrErrrÚtostringOs2
þþþþzRelOp.tostringN)rr    r
rr<r=r>r?r@rAÚclassmethodrrrFrIrrrrr+;sr+c@s,eZdZdZdZdZdZdZdZdZ    dZ
d    S)
ÚArithOpzC
    Used in Op.APPLY expression to specify the function part.
    rrr,r-r.r/éN)rr    r
rÚPOSZNEGZADDZSUBZMULÚDIVÚPOWrrrrrKYsrKc@seZdZdS)ÚOpErrorN©rr    r
rrrrrPfsrPc@sDeZdZdZdZdZdZdZdZdZ    dZ
d    Zd
ZdZ dZd ZdZdS)Ú
Precedencez4
    Used as Expr.tostring precedence argument.
    rrrr,r-r/rLéré érrN)rr    r
rÚATOMÚPOWERÚUNARYÚPRODUCTÚSUMr>r<ZLANDZLORr"ZASSIGNÚTUPLEÚNONErrrrrRjsrRcCs<| |¡}|dkr|||<n||}|r2|||<n||=dS©N)Úget)ÚdÚkÚvÚcrrrÚ
_pairs_adds
 
 
rcc@seZdZdS)ÚExprWarningNrQrrrrrdsrdcCstj|tdddS)Nr)Ú
stacklevel)ÚwarningsÚwarnrd)ÚmessagerrrÚewarnsric@s$eZdZdZeejfddZddZddZ    dd    Z
d
dZdd ZddZ ddZddZddZejejfddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Z d0d1Z!d2d3Z"d4d5Z#d6d7Z$d8d9Z%d:d;Z&d<d=Z'd>d?Z(d@dAZ)dBS)CrzfRepresents a Fortran expression as a op-data pair.
 
    Expr instances are hashable and sortable.
    cCst||dS)z.Parse a Fortran expression to a Expr.
        ©rE)rF)rDrErrrÚparsesz
Expr.parsecCs0t|tst|tjkrbt|tr.t|dks2tt|dtsDtt|dttfs^t|n¾|tjkr¶t|trt|dkstt|dt    stt|dttfs²t|nj|tj
krÞt|trÖt|dksÚtnB|tjkr`t|trt|dkstt|dtr<|dddt|dddks@tt|dttfs t|nÀ|tjkrt |dk    s tn|tjtjfkrÄt|ts¤ttdd|Ds t|n\|tjtjfkrêt|ts tn6|tjkrTt|trt|dkstt |ddk    s*tt|dts>tt|dts tnÌ|tjkrt|trzt|dks~tt |ddk    s tn|tjkrÂt|tr¼t|dks tn^|tjtjfkræt|ts tn:|tjkrt|trt|dks tntd|||_||_dS)    Nrrr)z""z''z@@css|]}t|tVqdSr])Ú
isinstancer©Ú.0ÚitemrrrÚ    <genexpr>Âsz Expr.__init__.<locals>.<genexpr>r,z$unknown op or missing sanity check: )rlrÚAssertionErrorrÚtupleÚlenÚintÚstrrÚfloatrrr!Úhashr r%Úallr'r(Údictr#r$r"r)r*rr&ÚNotImplementedErrorÚopÚdata)rHr{r|rrrÚ__init__¢sV
 
 
 ÿ    ÿz Expr.__init__cCs"t|to |j|jko |j|jkSr])rlrr{r|©rHÚotherrrrÚ__eq__äs
 
 
ÿ
þzExpr.__eq__cCsl|jtjtjfkr&tt|j ¡}n8|jtjkrX|jddtt|jd ¡}n|j}t    |j|fS©Nr)
r{rr'r(rrÚsortedr|Úitemsr#rw)rHr|rrrÚ__hash__és&z Expr.__hash__cCsÜt|trØ|j|jk    r&|jj|jjkS|jtjtjfkr\tt|j     
¡tt|j     
¡kS|jtjkrÌ|j    dd|j    ddkr |j    dd|j    ddkStt|j    d 
¡tt|j    d 
¡kS|j    |j    kStSr) rlrr{Úvaluerr'r(rrrr|rr#ÚNotImplementedr~rrrÚ__lt__òs
ÿÿzExpr.__lt__cCs||kp||kSr]rr~rrrÚ__le__ózExpr.__le__cCs
||kSr]rr~rrrÚ__gt__rzExpr.__gt__cCs
||kSr]rr~rrrÚ__ge__rzExpr.__ge__cCs t|jd|jd|jdS©Nú(ú, ú))Útyperr{r|©rHrrrÚ__repr__sz Expr.__repr__cCs| ¡Sr])rIrrrrÚ__str__
szExpr.__str__csv|jtjtjfkr`|jddkr&tjntj}t|jd|jddkrVd|jdnd}nø|jtj    krd 
fdd|jD¡}d    |d
}tj}n¼|jtjkr¼tj}t|j}n|jtjkrü|jd}|jddkrò|jdd|}tj}n\|jtj kr:d 
fdd|jD¡}d|d }tj}n|jtjkr$g}t|j ¡D]¢\}}|dkrxd}|}nd}|dkr|jtjd}n2|tdkr°t|}n|d|jtjd}|rÜ| |¡n|dkrð| d¡| |¡qZd 
|¡pd}|rtjntj}n4|jtjkrg}    g}
t|j ¡D]ö\}}d}|dkrp|jtjd} n²tjkr|tddkr®|jtjd} d 
| g|¡} nX|tddkrä|jtjd} |
| g|7}
qHn"|jtjd} d| d|d
} n|jtjdd|} |    r2|     |¡|     | ¡qH|
rl|    sV|    dg7}    |    dd    d 
|
¡d
g7}    d 
|    ¡pzd}|    rtjntj}nÆ|jtjkr8|j\}}}|tjkrðtjkrðfdd|D\}}|d|}tj}nDfdd|D}|dd| ¡D7}|d    d 
|¡d
}tj}n |jtjkr|jd}fd d|jdd!D}|dd 
|¡d }tj}nÌ|jtjkrÂfd"d|jD}d# 
|¡}tj}n|jtj krzfd$d|jD\}}}tjkrd    |d%|d&|d
}nbtj!kr6d    |d'|d(|d
}n<tj"kr\d)|d|d|d
}nt#d*|jd+tj}nÞ|jtj$kr¦d,|jjtj%d}tj%}n²|jtj&krÒd-|jjtj%d}tj%}n|jtj'krH|j\}}}|t(j)t(j*fkrtj)ntj+}|j|d}|j|d}|jd}|d.|d.|}nt#d/|j|j,|j,krrd    |d
S|S)0z0Return a string representation of Expr.
        rrr-Ú_Úrc3s|]}|jtjdVqdS©rjN©rIrRr[rmrjrrrpsÿz Expr.tostring.<locals>.<genexpr>rrc3s|]}|jtjdVqdSrrrmrjrrrp$sÿú[ú]z - ú + rjú * ú-Ú0rriöÿÿÿzpow(z ** Ú1ú/csg|]}|jtjdqS©rj©rIrRrY©rnÚargrjrrÚ
<listcomp>dsþÿz!Expr.tostring.<locals>.<listcomp>z / csg|]}|jtjdqSr rr¢rjrrr¤jsÿcSs$g|]\}}|d| tj¡qS)ú=)rIrRr\©rnr`rarrrr¤lsÿcsg|]}|jtjdqSr rr¢rjrrr¤rsÿNcsg|]}|jtjdqSr r¡r¢rjrrr¤wsÿz // csg|]}|jtjdqSr r©rnÚarjrrr¤|sþÿú?ú:z if z else zmerge(z tostring for z and ú&Ú*ú ztostring for op )-r{rrrr|rRrZrVrurÚjoinr!rr r'rrrIÚ    as_numberrYÚappendr(rrÚranger[rWr#rKrNr$r%r"rr rzr)rXr*r&r+r<r=r>r)rHZparent_precedencerEÚ
precedenceÚrZtermsÚtermÚcoeffr{ZfactorsÚtailÚbaseÚexpZfactorÚnameÚargsÚkwargsÚnumerÚdenomÚcondÚexpr1Úexpr2ÚropÚleftÚrightrrjrrI s0ÿÿÿÿ
 
 
ÿ
 
 
 
ÿ
 
 
ÿÿÿÿÿÿ
 
 
þ
 
ÿÿ
 
 
ÿ
 
ÿ
 
 
þÿÿz Expr.tostringcCs|Sr]rrrrrÚ__pos__szExpr.__pos__cCs|dS)NéÿÿÿÿrrrrrÚ__neg__¢szExpr.__neg__c    Cs¬t|}t|tr¨|j|jkrØ|jtjtjfkr^t|jd|jdt    |jd|jdS|jtj
kr|j\}}|j\}}t||||S|jtjkrØt|jt |j}|j ¡D]\}}t|j||q¸t|S|jtj
kr|jtjtjfkr|t|S|jtjtjfkr4|jtj
kr4t||S|jtjkrf|jtjkrf|t||jddS|jtjkr|jtjkrt||jdd|St|t|StS©Nrr)Úkind)Úas_exprrlrr{rrrr¯r|ÚmaxrÚ
as_complexr'ryrrcÚ    normalizeÚas_realÚas_termsr)    rHrÚr1Úi1Úr2Úi2r³r`rarrrÚ__add__¥s6þ
 
""zExpr.__add__cCst|trt||StSr]©rlÚnumber_typesr¯rr~rrrÚ__radd__Ás
z Expr.__radd__cCs
||Sr]rr~rrrÚ__sub__ÆszExpr.__sub__cCst|trt||StSr]rÔr~rrrÚ__rsub__És
z Expr.__rsub__c CsVt|}t|trR|j|jkrN|jtjtjfkr`t|jd|jdt    |jd|jdS|jtj
kr¢|j\}}|j\}}t||||||||S|jtjkrêt|jt |j}|j ¡D]\}}t|j||qÊt|S|jtjkrNt|ji}|j ¡D]6\}    }
|j ¡D] \}}t|j|    ||
|q qt|S|jtj
kr||jtjtjfkr||t|S|jtj
krª|jtjtjfkrªt||S|jtjkrÜ|jtjkrÜ|t||jddS|jtjkr|jtjkrt||jdd|S|jtjkr(|t|S|jtjkrBt||St|t|StSrÇ)rÉrlrr{rrrr¯r|rÊrrËr(ryrrcrÌr'rÍrÎÚ
as_factorsr) rHrrÏrÐrÑrÒr³r`raÚt1Úc1Út2Úc2rrrÚ__mul__ÎsHÿ
 
"""zExpr.__mul__cCst|trt||StSr]rÔr~rrrÚ__rmul__÷s
z Expr.__rmul__cCsÖt|}t|trÒ|jtjkrÄ|jd}|dkr8tdS|dkrD|S|dkr|jtjkrt|ji}|j     ¡D]\}}|||j|<qnt
|S|||dS|dkr´||dSttj||iSttj ||StS)NrrrÅ)rÉrlrr{rrr|r¯r(rrÌÚas_applyrKrOr)rHrÚexponentr³r`rarrrÚ__pow__üs(
 
zExpr.__pow__cCs(t|}t|tr$tttj||StSr])rÉrlrrÌràrKrNrr~rrrÚ__truediv__s
zExpr.__truediv__cCst|}t|tr||StSr]©rÉrlrrr~rrrÚ__rtruediv__s
zExpr.__rtruediv__cCs*t|}t|tr&tttj||fStSr])rÉrlrrÌrr%rr~rrrÚ__floordiv__!s
zExpr.__floordiv__cCst|}t|tr||StSr]rär~rrrÚ __rfloordiv__)s
zExpr.__rfloordiv__cOs(t|ftt|tdd| ¡DS)Ncss|]\}}|t|fVqdSr]©rÉr¦rrrrp6sz Expr.__call__.<locals>.<genexpr>)ràÚmaprÉryr)rHrºr»rrrÚ__call__/sÿz Expr.__call__cCsFt|}t|ts|f}t|dkr4td|dttj|f|S)Nrz/C-index should be a single expression but got `ú`)rÉrlrrrsrirrr$)rHÚindexrrrÚ__getitem__8s
zExpr.__getitem__csb|jtjkrh |¡}|dkr"|St d|j¡}|rd| ¡\}}|dkrPt|S|dksdt    ||f|S|jtj
tjtjfkr|S|jtj tjfkr´t|jtfdd|jDS|jtjkrätt|jtfdd|jDS|jtjkrVd}|j ¡D]6\}}|dkr"| ¡|}n|| ¡|7}q|dkrRtdtd    S|S|jtjkrÈd}|j ¡D]6\}    }
|dkr|     ¡|
}n||     ¡|
9}qr|dkrÄtd
tdS|S|jtjkr>|j\}}} t|trø| ¡}tfdd|D}tfd d|  ¡D} tt|j||| fS|jtjkr¢|jd    }t|trl| ¡}tfdd|jddD}tt|j|f|S|jtjkrØtfdd|jD}tt|j|S|jtjtjfkrtt|j|j ¡S|jtj krH|j\}}}| ¡}| ¡}tt|j|||fSt!d|jd|dS)zRecursively substitute symbols with values in symbols map.
 
        Symbols map is a dictionary of symbol-expression pairs.
        Nz$\A(@__f2py_PARENTHESIS_(\w+)_\d+@)\Z©ÚROUNDDIVÚSQUAREÚROUNDc3s|]}| ¡VqdSr]©Ú
substituterm©Úsymbols_maprrrpVsÿz"Expr.substitute.<locals>.<genexpr>c3s|]}| ¡VqdSr]ròrmrôrrrpYsÿz?substitute: empty TERMS expression interpreted as int-literal 0rzAsubstitute: empty FACTORS expression interpreted as int-literal 1rc3s|]}| ¡VqdSr]ròr§rôrrrpwsc3s |]\}}|| ¡fVqdSr]ròr¦rôrrrpxsÿc3s|]}| ¡VqdSr]ròr§rôrrrpsc3s|]}| ¡VqdSr]ròr§rôrrrpszsubstitute method for z: )"r{rr!r^ÚreÚmatchr|ÚgroupsÚas_arrayrqrrrr rrrrr%rÌr'rrórir¯r(r#rlryr$r"r)r*r&rz)rHrõrÚmrÚparenr³r´rµr·ráÚtargetrºr»ÚfuncÚoperandsrÁrÂrÃrrôrróBs
ÿ
ÿ
 
 
 
 
ÿ
 
 
 
zExpr.substitutecsª|f}|dk    r|S|jtjtjtjtjfkr:|S|jtjtjtjtj    fkr|t
t|jtfdd|j DS|jtjtjfkri}|j  ¡D]V\}}|jf}t|trÔ|jfn|}||krì|||}|||<qt
t|j|S|jtjkr|j d}t|tr<|jfn|}    tfdd|j dD}
tfdd|j d ¡D}t
t|j|    |
|fS|jtjkr|j d}t|trÐ|jfn|}tfd    d|j ddD}t
t|j|f|S|jtjtjfkrBt
t|j|j jfS|jtjkr|j \} }}|jf}|jf}t
t|j| ||fStd
|jdS)aBTraverse expression tree with visit function.
 
        The visit function is applied to an expression with given args
        and kwargs.
 
        Traverse call returns an expression returned by visit when not
        None, otherwise return a new normalized expression with
        traverse-visit sub-expressions.
        Nc3s |]}|jfVqdSr]©Útraverserm©rºr»Úvisitrrrpsÿz Expr.traverse.<locals>.<genexpr>rc3s |]}|jfVqdSr]rÿ©rnÚoperandrrrrp¯sÿrc3s(|] \}}||jffVqdSr]rÿr¦rrrrp±sÿrc3s |]}|jfVqdSr]rÿ)rnrìrrrrp¸sÿztraverse method for )r{rrrrr!rr r%r"rÌrrrr|r'r(rrrlr#ryr$r)r*r&rz)rHrrºr»Úresultr|r`raÚobjrýrþZ
kwoperandsÚindicesrÁrÂrÃrrrrsl
þÿÿ
 
ÿÿÿÿ
ÿÿÿÿz Expr.traversecs*g}|ffdd    }| |¡t|dkS)z&Check if self contains other.
        cs"|r|S|kr| d¡|SdS)Nr)r°©ÚexprÚfound©rrrrÊs
 
zExpr.contains.<locals>.visitr)rrs)rHrr
rrrrÚcontainsÅs
z Expr.containscCs t}|fdd}| |¡|S)z3Return a set of symbols contained in self.
        cSs|jtjkr| |¡dSr])r{rr!ÚaddrrrrrÚszExpr.symbols.<locals>.visit©Úsetr)rHr
rrrrÚsymbolsÕs
zExpr.symbolscs$t}|ffdd    | ¡|S)zFReturn a set of expressions used as atoms in polynomial self.
        cs¾|jtjkr&|jD]}| ¡q|S|jtjtjfkr<dS|jtjkrt|jdt    r|jdt    j
kr|jdd ¡|SdS|jtjtjfkr|S|  |¡|jtjtjfkrº|SdS©Nrr)r{rr(r|rr'rr#rlrKrOrrr r$)r    r
Úb©rrrrçs 
 
z$Expr.polynomial_atoms.<locals>.visitr)rHr
rrrÚpolynomial_atomsâs
zExpr.polynomial_atomscCsz| |tdi¡}||}| |tdi¡}t|||\}}|tdkrrtd|d|d|d|d|
||fS)zReturn a, b such that a * symbol + b == self.
 
        If self is not linear with respect to symbol, raise RuntimeError.
        rrznot a z-linear equation: rrz == )rór¯Úas_numer_denomÚRuntimeError)rHÚsymbolrZaxr¨ZzerorrrrÚlinear_solveÿs&zExpr.linear_solveN)*rr    r
rÚstaticmethodrrrkr}rrrrrrrrrRr\r rIrÄrÆrÓrÖr×rØrÞrßrârãrårærçrêrírórrrrrrrrrrsJB    ÿ
)    
K8 cCs"t|ts|S|jtjkrài}|j ¡D]p\}}|dkr:q(|jtjkrZ|dkrZ||}d}|jtjkr|j ¡D]\}}t||||qpq(t|||q(t    |dkr®t
dSt    |dkrÔ| ¡\\}}|dkrÔ|Sttj|S|jtjkrÈd}i}|j ¡D]\}}|dkrq|jtjkrPt|trP|dkrP|||d}d}|jtj tjfkrª|dkr~||jd9}n*|dkr||jd|9}nt|||nf|jtjkr|dkröt|trö|j ¡D]\}    }
t||    |
|qØnt|||nt|||qt    |dks,|dkrDt|ts<tt
|St    |dkr| ¡\\}}|dkrp|}nttj|}|dkr|Sttj||iS|dkr°ttj|Sttjttj||iS|jtjkrÎ|jdtjkrÎ|jd\}}t|\}}t|\} }t|trDt|trDt||}||||}}n||d}}|jtjkr¨|jdtjkr¨|jdd|}|jdd| |}ttj||S| jtjkrþ| jdtjkrþ| jdd||}| jdd|}ttj||Stt|j}t| j ¡D]\}}t|||qii}}| ¡D](\}}|dkrb|||<n
|||<qFtttj||}tttj||}|jtj tjfkrÀ|jddkrÀ|Sttj||S|jtjkrÊ|jdg}|jddD]¬}|d}|jtjkr|jtjkr|jdddkr|jdd|jddkrt|jddd|jdddt|jd|jd}||d<n
| |¡qöt    |dkrº|dSttjt|S|jtj krt!t|j\}}}|jtj kr|jdr|S|Sttj |||fS|S)z7Normalize Expr and apply basic evaluation methods.
    rrNrÅz"')"rlrr{rr'r|rrrcrsr¯r(Ú integer_typesrrrÕrqr#rKrNÚ as_term_coeffrràryrÙrÌr%rÚ    as_stringrÊr°rrr"ré)rr_ÚtrbrÚrÛrµrÚeZb1Úe1ZdividendZdivisorrÜrÝÚgr¼r½ÚlstrDÚlastZnew_lastr¾r¿rÀrrrrÌsÞ
 
$
 
 
 
 
 
  
 
 
$
ÿ
þýü$ÿ
rÌcCs\t|trt|j|jSt|tr*t|St|tr@tt    |St|t
rXt
tt|S|S)z.Convert non-Expr objects to Expr objects.
    ) rlÚcomplexrËÚrealÚimagrÕr¯rurÚreprrrrérÉ©rrrrrÉs
 
 
 
rÉcCsttj|S)zJReturn object as SYMBOL expression (variable or unparsed expression).
    )rrr!r'rrrÚ    as_symbol©sr(r-cCsht|trttj||fSt|tr4ttj||fSt|trT|jtjtjfkrT|Std|ddS)z/Return object as INTEGER or REAL constant.
    úcannot convert z to INTEGER or REAL constantN)    rlrtrrrrvrr{rP©rrÈrrrr¯¯s
 
 
r¯cCsHt|trttj||fSt|tr4|jtjkr4|Std|ddS)z'Return object as INTEGER constant.
    r)z to INTEGER constantN)rlrtrrrr{rPr*rrrÚ
as_integer¼s
 
r+cCst|trttjt||fSt|tr8ttj||fSt|trx|jtjkrR|S|jtjkrxttjt|jd|fSt    d|ddS)z$Return object as REAL constant.
    rr)z to REAL constantN)
rlrtrrrrvr{rr|rPr*rrrrÍÇs
 
 
rÍrcCsttj||fS)zBReturn object as STRING expression (string literal constant).
    )rrrr*rrrrÖsrcCst|tr|f}ttj|S)z8Return object as ARRAY expression (array constant).
    )rlrrr r'rrrrùÜs
rùcCsttjt|t|fS)zDReturn object as COMPLEX expression (complex literal constant).
    )rrrrÉ)r$r%rrrrËäsrËcOs.ttj|ttt|tdd| ¡DfS)zIReturn object as APPLY expression (function call, constructor, etc.)
    css|]\}}|t|fVqdSr]rèr¦rrrrpïszas_apply.<locals>.<genexpr>)rrr#rrrérÉryr)rýrºr»rrrràês
ÿÿràcCsttj|||fS)z<Return object as TERNARY expression (cond?expr1:expr2).
    )rrr")r¾r¿rÀrrrÚ
as_ternaryòsr,cCsttj|S)z-Return object as referencing expression.
    )rrr)©r    rrrÚas_reføsr.cCsttj|S)z/Return object as dereferencing expression.
    )rrr*r-rrrÚas_derefþsr/cCsttjtj||fSr])rrr&r+r<©rÂrÃrrrÚas_eqsr1cCsttjtj||fSr])rrr&r+r=r0rrrÚas_nesr2cCsttjtj||fSr])rrr&r+r>r0rrrÚas_ltsr3cCsttjtj||fSr])rrr&r+r?r0rrrÚas_lesr4cCsttjtj||fSr])rrr&r+r@r0rrrÚas_gtsr5cCsttjtj||fSr])rrr&r+rAr0rrrÚas_gesr6cCs¦t|trt|}|jtjkr"|S|jtjkrPttjtd|jd|jdiS|jtj    kr~ttjt
d|jd|jdiSttj|diStdt|ddS)z+Return expression as TERMS expression.
    rrr)ú to terms ExprN) rlrrÌr{rr'rr+r|rrÍrPrr'rrrrÎs
""rÎcCsôt|trÜt|}|jtjkr"|S|jtjkr~t|jdkr~|j     ¡\\}}|dkrdttj|diSttj|dt 
|¡diS|jtjkrÌ|jdtj krÌ|jdsÌttj|jddd|jdddiSttj|diStdt|ddS)z-Return expression as FACTORS expression.
    rrrrÅr)r7N)rlrrÌr{rr(r'rsr|rÚnumberr#rKrNrPr)rr´rµrrrrÙ+s$
ÿþ(rÙcCsþt|træt|}|jtjkr8td|jd|jdfS|jtjkr^t    d|jd|jdfS|jtj
krt|jdkr|j ¡\\}}||fS|jtj krÞ|jdtjkrÞt|jdd\}}ttj||jdd|fS|dfStdt|ddS)z0Return expression as term-coefficient pair.
    rrr)z to term and coeffN)rlrrÌr{rrr+r|rrÍr'rsrr#rKrNrràrPr)rr´rµrrbrrrr@s
rcCsNt|tr6t|}|jtjtjtjtjtj    tj
fkrB|tdfS|jtjkr¨|j dtjkr|j dstt|j d\}}|d|d|d|dfS|tdfS|jtjkr¢gg}}|j  ¡D]0\}}t|\}}||}| |¡| |¡qÊtdtd}}tt|D]L}    ||    }tt|D]}
|    |
kr2|||
9}q2||7}|||    9}q|jtjtjfkr|j ddkr||}}||fS|jtjkr6tdtd}}|j  ¡D]`\}}t|\} }|dkr|| |9}|||9}n&|dkrÌ|||9}|| |9}qÌ||fStdt|ddS)z+Return expression as numer-denom pair.
    rrrr)z to numer and denomN)rlrrÌr{rrrrr!r$r"r¯r#r|rKrNrérr'rr°r±rsr(rPr)rZnumersZdenomsr´rµÚnr_r¼r½ÚiÚjrrZbnumerZbdenomrrrrUsTÿ 
 
 
$
 
rccsd}|d7}|VqdSrr)ÚcounterrrrÚ_countersr=csJifdd}t djdddd||¡}d|ks6td    |ksBt|fS)
zgReplace quoted substrings of input string.
 
    Return a new string and a mapping of replacements.
    cs\| ¡dd\}}|r$|dd}ddd|d}|d|dt ¡d    }||<|S)
NrrÅZSINGLEÚDOUBLE)ú'ú"rz@__f2py_QUOTES_rú@)røÚCOUNTERÚ__next__)rúrÈrÚpr`©r_rrÚreplszeliminate_quotes.<locals>.replz+({kind}_|)({single_quoted}|{double_quoted})z
\w[\w\d_]*z('([^'\\]|(\\.))*')z("([^"\\]|(\\.))*"))rÈÚ single_quotedZ double_quotedr@r?)röÚsubÚformatrq)rDrFZnew_srrErÚeliminate_quotess
ýürJcCsD| ¡D]6\}}|d| d¡}|r.|d7}| |||¡}q|S)z!Inverse of eliminate_quotes.
    NrAr)rÚfindÚreplace)rDr_r`rarÈrrrÚ insert_quotesªsrMc Cs6d\}}t|}dD]2\}}| |¡}|dkr0q||kr|}||}}q|dkrX|ifS|}| ||¡}| ||d|¡| ||d|¡kr¾| ||d¡}|dkrhtd||d|qhdd    d
dd|}d |dt ¡d}    ||t||}
t||t|d\}}|
||    <|d||    ||fS)zzReplace substrings of input that are enclosed in parenthesis.
 
    Return a new string and a mapping of replacements.
    )NN))ú(/ú/)z()z{}z[]rÅNrzMismatch of z parenthesis in rñrðÚCURLYrï)rrÚ{rNú@__f2py_PARENTHESIS_rrA)rsrKÚcountÚ
ValueErrorrBrCÚreplace_parenthesis) rDrÂrÃZmn_iZleft_Zright_r:r;rDr`rar³r_rrrrUµs.
 
$rUcCs | d¡st|| d¡dS)NrRrr-)Ú
startswithrqÚsplit)rDrrrÚ_get_parenthesis_kindàsrXcCsZ| ¡D]L\}}t|}tddddd|}tdddd    d|}| ||||¡}q|S)
z$Inverse of replace_parenthesis.
    rrrQrN)rñrðrPrïrrÚ}rO)rrXryrL)rDr_r`rarDrÂrÃrrrÚunreplace_parenthesisåsrZcCs8t|d |¡}t|tr|Std|d|ddS)z®Create an expression from a string.
 
    This is a "lazy" parser, that is, only arithmetic operations are
    resolved, non-arithmetic operations are treated as symbols.
    rjzfailed to parse `z` to Expr instance: got `rëN)Ú_FromStringWorkerrkrlrrT)rDrEr³rrrrFðs
rFc@s$eZdZddZddZddZdS)Ú_PaircCs||_||_dSr]r0)rHrÂrÃrrrr}ÿsz_Pair.__init__cCs@|j|j}}t|tr"| |¡}t|tr6| |¡}t||Sr])rÂrÃrlrrór\)rHrõrÂrÃrrrrós
 
 
 
z_Pair.substitutecCs t|jd|jd|jdSr)rrrÂrÃrrrrrsz_Pair.__repr__N)rr    r
r}rórrrrrr\üsr\c@s4eZdZejfddZddZddZddd    Zd
S)r[cCsd|_d|_||_dSr])ÚoriginalÚ
quotes_maprErGrrrr}sz_FromStringWorker.__init__cCst||jSr])rMr^)rHrDrrrÚfinalize_stringsz!_FromStringWorker.finalize_stringcCs||_t|\}|_| |¡Sr])r]rJr^Úprocess)rHÚinpZunquotedrrrrksz_FromStringWorker.parser    csÆt|ttfr*t|fdd|DSt|tsDtt||ft|\}| ¡}fddd|krÈ| d¡}dkrt     |¡Sdkr´t
|dkr´t     |¡Std    d
|t  d|¡}|r&dksêt| ¡\}}}     |¡}     |¡}     |¡}t|||SjtjkrFt  d|t j¡}nt  d |¡}|r¸| ¡\}    }
}jtjkrd|
d}
     |    |f¡\}    }tj|
jd}
ttj|
|    |fSt  d|¡}|rî| ¡\}} | } t|     | ¡St  d|¡}t
|dkr     |dpd¡}t|ddd|dddD]J\}}     |¡}| ¡}|dkrp||7}n|dks~t||8}q>|SjtjkrÊd|krÊ| d¡}ttjt     |¡St  djtjkrâ|n
| dd¡¡}t
|dkr|}jtjk    r"dd|D}     |d¡}t|ddd|dddD]F\}}     |¡}| ¡}|dkr|||9}n|dkst||}qN|S| d¡s²| d ¡rètj tj!d!|d}     |dd¡}t||Sjtjk    rNd|krNtt"| d¡}     |d¡}|ddD]}     |¡}||}q0|St  d"j#d#d$d%|¡}|r¤| ¡\} }}|r| $¡rt%|}t&t%| |p d&St  d'j#d(d)d$d*|¡}|r,| ¡\} }}}|rê| $¡rêt%|}|  '¡} d+| krt(t)|  d+d,¡|pd-St(t)| |p(d&S|j*kr`|d| +d.¡}t,j*||p\dS|krÒt-|}     ||d/krdnd¡}|d/kr®t|tr®|S|d0krÒt|trÊ|f}t.|St  d1|¡}|r~| ¡\}}}     |¡}     |dd2d¡}t|ts*|f}|d/krht/d3d|D}td4d|D}t0|f||S|d5ksvt||St  d6|¡}|rt1|S 2|¡}t3d7|d8j4d9t1|S):a´Parse string within the given context.
 
        The context may define the result in case of ambiguous
        expressions. For instance, consider expressions `f(x, y)` and
        `(x, y) + (a, b)` where `f` is a function and pair `(x, y)`
        denotes complex number. Specifying context as "args" or
        "expr", the subexpression `(x, y)` will be parse to an
        argument list or to a complex number, respectively.
        c3s|]} |¡VqdSr])r`)rnZs_)ÚcontextrHrrrp)sz,_FromStringWorker.process.<locals>.<genexpr>cs*t|ttfr t|t|St|Sr])rlÚlistrrrrérZ)r³)Úraw_symbols_mapÚrestorerrre1sz*_FromStringWorker.process.<locals>.restoreú,rºr    rz&parsing comma-separated list (context=z): z\A([^?]+)[?]([^:]+)[:](.+)\Zz+\A(.+)\s*[.](eq|ne|lt|le|gt|ge)[.]\s*(.+)\Zz7\A(.+)\s*([=][=]|[!][=]|[<][=]|[<]|[>][=]|[>])\s*(.+)\ZÚ.rjz\A(\w[\w\d_]*)\s*[=](.*)\Zz((?<!\d[edED])[+-])rrrNú+rz//z(?<=[@\w\d_])\s*([*]|/)ú**ú@__f2py_DOUBLE_STAR@cSsg|]}| dd¡qS)rjri)rLrrrrr¤~sÿz-_FromStringWorker.process.<locals>.<listcomp>r¬rr«)r¬r«z\A({digit_string})({kind}|)\Zz\d+z_(\d+|\w[\w\d_]*))Zdigit_stringrÈr-z7\A({significant}({exponent}|)|\d+{exponent})({kind}|)\Zz[.]\d+|\d+[.]\d*z[edED][+-]?\d+)ZsignificantrárÈr_rérArñrîz4\A(.+)\s*(@__f2py_PARENTHESIS_(ROUND|SQUARE)_\d+@)\ZrÅcss$|]}t|tr|j|jfVqdSr])rlr\rÂrÃr§rrrrpÒs
ÿcss|]}t|ts|VqdSr])rlr\r§rrrrpÔs
rðz\A\w[\w\d_]*\Zzfromstring: treating z as symbol (original=r)5rlrcrrrrurqrUÚstriprWr`rsrËrzrör÷rør,rErr ÚIr+rFrrr&r\Úzipr%rrLrVr*r)ÚreversedrIÚisdigitrtr+rBrÍrvr^rKrrXrùryràr(r_rir])rHrDrbr³rþrúÚoperr¿rÀrÂrÁrÃÚkeynamerrr{rrrÈrûrrürºr»r)rbrdrerHrr`s8
ÿ
 
 
ÿÿ&
 
ÿ
þÿ&
 
 
 
 
þþüü
 
ÿ
 
ÿ
ÿz_FromStringWorker.processN)r    )    rr    r
rrr}r_rkr`rrrrr[sr[)r-)r-)r-)r)r):rÚ__all__rörfÚenumrÚmathrrrr+rKÚ    ExceptionrPrRrtrrvrÕrcÚUserWarningrdrirrÌrÉr(r¯r+rÍrrùrËràr,r.r/r1r2r3r4r5r6rÎrÙrrr=rBrJrMrUrXrZrrFr\r[rrrrÚ<module>sn      ~
 
 
 
 
 
-+