HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
Upload Files
File: //usr/local/lib/python3.10/dist-packages/numpy/f2py/__pycache__/symbolic.cpython-310.pyc
o

���g��@s�dZdgZddlZddlZddlmZddlmZGdd�de�ZGdd	�d	e�Z	Gd
d�de�Z
Gdd
�d
e�ZGdd�de�Z
Gdd�de�ZefZeefZdd�ZGdd�de�Zdd�ZGdd�d�Zdd�Zdd�Zdd�Zd[d d!�Zd[d"d#�Zd[d$d%�Zd\d'd(�Zd)d*�Zd]d+d,�Z d-d.�Z!d/d0�Z"d1d2�Z#d3d4�Z$d5d6�Z%d7d8�Z&d9d:�Z'd;d<�Z(d=d>�Z)d?d@�Z*dAdB�Z+dCdD�Z,dEdF�Z-dGdH�Z.dIdJ�Z/e/�Z0dKdL�Z1dMdN�Z2dOdP�Z3dQdR�Z4dSdT�Z5ej6fdUdV�Z7GdWdX�dX�Z8GdYdZ�dZ�Z9dS)^a�Fortran/C symbolic expressions

References:
- J3/21-007: Draft Fortran 202x. https://j3-fortran.org/doc/year/21/21-007.pdf

Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
Copyright 2011 -- present NumPy Developers.
Permission to use, modify, and distribute this software is given under the
terms of the NumPy License.

NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
�Expr�N)�Enum)�gcdc@seZdZdZdZdZdZdS)�Languagez2
    Used as Expr.tostring language argument.
    r��N)�__name__�
__module__�__qualname__�__doc__�Python�Fortran�C�rr�>/usr/local/lib/python3.10/dist-packages/numpy/f2py/symbolic.pyr$s
rc@sLeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
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
ejfdd	��Z
ejfd
d�ZdS)
�RelOpzH
    Used in Op.RELATIONAL expression to specify the function part.
    rr����cCsR|tjurtjtjtjtjtjtjd�|�	�Stjtjtjtjtjtjd�|S)N)�.eq.�.ne.�.lt.�.le.�.gt.�.ge.)�==�!=�<�<=�>�>=)
rr
r+�EQ�NE�LT�LE�GT�GE�lower)�cls�s�languagerrr�
fromstringMs
����zRelOp.fromstringcCsb|tjurtjdtjdtjdtjdtjdtjdi|Stjdtjdtjd	tjd
tjdtjdi|S)
Nr0r1r2r3r4r5r6r7r8r9r:r;)	rr
r+r<r=r>r?r@rA��selfrErrr�tostringVs
����zRelOp.tostringN)rr	r
rr<r=r>r?r@rA�classmethodrrrFrIrrrrr+Bsr+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�POS�NEG�ADD�SUB�MUL�DIV�POWrrrrrK`srKc@�eZdZdS)�OpErrorN�rr	r
rrrrrUm�rUc@sDeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdZdS)�
Precedencez4
    Used as Expr.tostring precedence argument.
    rrrr,r-r/rL�r�
�rrN)rr	r
r�ATOM�POWER�UNARY�PRODUCT�SUMr>r<�LAND�LORr"�ASSIGN�TUPLE�NONErrrrrXqsrXcCs@|�|�}|dur|||<dS||}|r|||<dS||=dS�N)�get)�d�k�v�crrr�
_pairs_add�s

rlc@rT)�ExprWarningNrVrrrrrm�rWrmcCstj|tdd�dS)Nr)�
stacklevel)�warnings�warnrm)�messagerrr�ewarn��rrc@s$eZdZdZeejfdd��Zdd�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dd�Zdd�Zdd�Zejejfdd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Z d0d1�Z!d2d3�Z"d4d5�Z#d6d7�Z$d8d9�Z%d:d;�Z&d<d=�Z'd>d?�Z(d@dA�Z)dBS)CrzfRepresents a Fortran expression as a op-data pair.

    Expr instances are hashable and sortable.
    cCst||d�S)z.Parse a Fortran expression to a Expr.
        �rE)rF)rDrErrr�parse�sz
Expr.parsecCs
t|t�sJ�|tjur1t|t�rt|�dksJ�t|dt�s"J�t|dttf�s/J|���nL|tjur[t|t�rAt|�dksCJ�t|dt�sLJ�t|dttf�sYJ|���n"|tj	urot|t�rkt|�dksmJ��n|tj
ur�t|t�rt|�dks�J�t|dt�r�|dddt|d�d�dvs�J�t|dttf�s�J|��n�|tjur�t|�dus�J�n�|tj
tjfvr�t|t�s�J�tdd�|D��s�J|��n�|tjtjfvr�t|t�s�J�n�|tju�rt|t�r�t|�dks�J�t|d�du�sJ�t|dt��sJ�t|dt��sJ�nf|tju�r8t|t��r*t|�dk�s,J�t|d�du�s7J�nE|tju�rNt|t��rKt|�dk�sMJ�n/|tjtjfv�r`t|t��s_J�n|tju�rvt|t��rst|�dk�suJ�ntd|����||_||_dS)	Nrrr)z""z''z@@css�|]}t|t�VqdSrf)�
isinstancer��.0�itemrrr�	<genexpr>���z Expr.__init__.<locals>.<genexpr>r,z$unknown op or missing sanity check: )rvrr�tuple�len�int�strr�floatrrr!�hashr r%�allr'r(�dictr#r$r"r)r*rr&�NotImplementedError�op�data)rHr�r�rrr�__init__�sT



&
  �
z
Expr.__init__cCs"t|t�o|j|juo|j|jkSrf)rvrr�r��rH�otherrrr�__eq__�s


�
�zExpr.__eq__cCsl|jtjtjfvrtt|j����}n|jtjur,|jdd�tt|jd����}n|j}t	|j|f�S�Nr)
r�rr'r(r|�sortedr��itemsr#r�)rHr�rrr�__hash__�s&z
Expr.__hash__cCs�t|t�rl|j|jur|jj|jjkS|jtjtjfvr.tt|j	�
���tt|j	�
���kS|jtjurf|j	dd�|j	dd�krP|j	dd�|j	dd�kStt|j	d�
���tt|j	d�
���kS|j	|j	kStSr�)
rvrr��valuerr'r(r|r�r�r�r#�NotImplementedr�rrr�__lt__�s
��zExpr.__lt__cCs||kp||kSrfrr�rrr�__le__szExpr.__le__cCs
||kSrfrr�rrr�__gt__
�
zExpr.__gt__cCs
||kSrfrr�rrr�__ge__r�zExpr.__ge__cCs t|�j�d|j�d|j�d�S�N�(�, �))�typerr�r��rHrrr�__repr__� z
Expr.__repr__cCs|��Srf)rIr�rrr�__str__�zExpr.__str__csb|jtjtjfvr0|jddkrtjntj}t|jd�|jddkr+d|jd��nd}�n�|jtj	urNd�
�fdd�|jD��}d	|d
}tj}�n�|jtjur^tj}t|j�}�n�|jtjur~|jd}|jddkry|jdd|}tj}�n�|jtj
ur�d�
�fdd�|jD��}d|d
}tj}�n�|jtju�r
g}t|j���D]K\}}|dkr�d}|}nd}|dkr�|jtj�d�}n|td�kr�t|�}n
|�d�|jtj�d�}|r�|�|�n	|dkr�|�d�|�|�q�d�
|�p�d}|�rtjntj}�n|jtju�r�g}	g}
t|j���D]z\}}d}|dk�r0|jtj�d�}
nX�tju�r{|tdd�v�rO|jtj�d�}
d�
|
g|�}
n9|tdd�v�ri|jtj�d�}
|
|
g|7}
�q|jtj�d�}
d|
�d|�d
�}
n
|jtj�d�d|��}
|	�r�|	�|�|	�|
��q|
�r�|	�s�|	dg7}	|	dd	d�
|
�d
g7}	d�
|	��p�d}|	�r�tjntj}�nb|jtju�r|j\}}}|tju�r�tju�r�fdd�|D�\}}|�d|��}tj}�n2�fdd�|D�}|dd�|��D�7}|�d	d�
|��d
�}tj}�n|jtju�r=|jd}�fd d�|jdd!�D�}|�dd�
|��d
�}tj}n�|jtju�rW�fd"d�|jD�}d#�
|�}tj}n�|jtj u�r��fd$d�|jD�\}}}�tju�r~d	|�d%|�d&|�d
�}n1�tj!u�r�d	|�d'|�d(|�d
�}n�tj"u�r�d)|�d|�d|�d
�}nt#d*|j�d+�����tj}no|jtj$u�r�d,|jjtj%�d�}tj%}nY|jtj&u�r�d-|jjtj%�d�}tj%}nC|jtj'u�r|j\}}}|t(j)t(j*fv�r�tj)ntj+}|j|�d�}|j|�d�}|j�d�}|�d.|�d.|��}nt#d/|j����|j,|j,k�r/d	|d
S|S)0z0Return a string representation of Expr.
        rrr-�_�r�c3� �|]}|jtj�d�VqdS�rtN�rIrXrdrwrtrrrz���z Expr.tostring.<locals>.<genexpr>r�r�c3r�r�r�rwrtrrrz+r��[�]z - � + rt� * �-�0rri����zpow(z ** �1�/c�g|]
}|jtj�d��qS�rt�rIrXr_�rx�argrtrr�
<listcomp>k�
�
�z!Expr.tostring.<locals>.<listcomp>z / cr�r�r�r�rtrrr�q��cSs$g|]\}}|d|�tj��qS)�=)rIrXre�rxrirjrrrr�ss�cr�r�r�r�rtrrr�yr�Ncr�r�r�r�rtrrr�~r�z // cr�r�r��rx�artrrr��r��?�:z if z else zmerge(z
tostring for z and �&�*� ztostring for op )-r�rrrr�rXr`r\rr�joinr!rr r'r�r�rI�	as_numberr_�appendr(rr�rangerdr]r#rKrRr$r%r"rr
r�r)r^r*r&r+r<r=r>r�)rH�parent_precedencerE�
precedence�r�terms�term�coeffr��factors�tail�base�exp�factor�name�args�kwargs�numer�denom�cond�expr1�expr2�rop�left�rightrrtrrIs.����


�

�

������



�

��


�
�

���z
Expr.tostringcCs|Srfrr�rrr�__pos__�szExpr.__pos__cCs|dS)N���rr�rrr�__neg__�r�zExpr.__neg__c	Cs�t|�}t|t�r�|j|jurk|jtjtjfvr.t|jd|jdt	|jd|jd��S|jtj
urG|j\}}|j\}}t||||�S|jtjurkt|jt
|j��}|j��D]\}}t|j||�q[t|�S|jtj
ur�|jtjtjfvr�|t|�S|jtjtjfvr�|jtj
ur�t|�|S|jtjur�|jtjur�|t||jdd�S|jtjur�|jtjur�t||jdd�|St|�t|�StS�Nrr)�kind)�as_exprrvrr�rrrr�r��maxr�
as_complexr'r�r�rl�	normalize�as_real�as_termsr�)	rHr��r1�i1�r2�i2r�rirjrrr�__add__�s6
�

zExpr.__add__cCst|t�rt|�|StSrf�rv�number_typesr�r�r�rrr�__radd__��
z
Expr.__radd__cCs
||Srfrr�rrr�__sub__�s
zExpr.__sub__cCst|t�rt|�|StSrfr�r�rrr�__rsub__�r�z
Expr.__rsub__c
Cs>t|�}t|t��r|j|jur�|jtjtjfvr/t|jd|jdt	|jd|jd��S|jtj
urP|j\}}|j\}}t||||||||�S|jtjurtt|jt
|j��}|j��D]\}}t|j||�qdt|�S|jtjur�t|ji�}|j��D]\}	}
|j��D]\}}t|j|	||
|�q�q�t|�S|jtj
ur�|jtjtjfvr�|t|�S|jtj
ur�|jtjtjfvr�t|�|S|jtjur�|jtjur�|t||jdd�S|jtjur�|jtjur�t||jdd�|S|jtju�r|t|�S|jtju�rt|�|St|�t|�StSr�)r�rvrr�rrrr�r�r�rr�r(r�r�rlr�r'r�r��
as_factorsr�)
rHr�r�r�r�r�r�rirj�t1�c1�t2�c2rrr�__mul__�sJ�

"�zExpr.__mul__cCst|t�rt|�|StSrfr�r�rrr�__rmul__�r�z
Expr.__rmul__cCs�t|�}t|t�ri|jtjurb|jd}|dkrtd�S|dkr"|S|dkrO|jtjurGt|ji�}|j�	�D]\}}|||j|<q7t
|�S|||dS|dkrZ||dSttj||i�Sttj
||�StS)Nrrr�)r�rvrr�rrr�r�r(r�r��as_applyrKrSr�)rHr��exponentr�rirjrrr�__pow__s(

zExpr.__pow__cCs(t|�}t|t�rtttj||��StSrf)r�rvrr�r�rKrRr�r�rrr�__truediv__s
zExpr.__truediv__cCst|�}t|t�r
||StSrf�r�rvrr�r�rrr�__rtruediv__"�
zExpr.__rtruediv__cCs*t|�}t|t�rtttj||f��StSrf)r�rvrr�rr%r�r�rrr�__floordiv__(s
zExpr.__floordiv__cCst|�}t|t�r
||StSrfr�r�rrr�
__rfloordiv__0r�zExpr.__rfloordiv__cOs.t|gtt|��Ritdd�|��D����S)Ncs� �|]\}}|t|�fVqdSrf�r�r�rrrrz=��z Expr.__call__.<locals>.<genexpr>)r��mapr�r�r�)rHr�r�rrr�__call__6s�z
Expr.__call__cCsFt|�}t|t�s|f}t|�dkrtd|�d��ttj|f|�S)Nrz/C-index should be a single expression but got `�`)r�rvr|r}rrrrr$)rH�indexrrr�__getitem__?s
zExpr.__getitem__csL|jtjur4��|�}|dur|St�d|j�}|r2|��\}}|dvr(t|�S|dks2J||f��|S|jtj	tj
tjfvrA|S|jtjtj
fvrZt|jt�fdd�|jD���S|jtjurrtt|jt�fdd�|jD����S|jtjur�d}|j��D]\}}|dur�|���|}q||���|7}q|dur�td�td	�S|S|jtjur�d}|j��D]\}	}
|dur�|	���|
}q�||	���|
9}q�|dur�td
�td�S|S|jtju�r|j\}}}
t|t�r�|���}t�fdd�|D��}t�fd
d�|
��D��}
tt|j|||
f��S|jtju�rH|jd	}t|t��r-|���}t�fdd�|jdd�D��}tt|j|f|��S|jtju�rct�fdd�|jD��}tt|j|��S|jtjtjfv�rytt|j|j�����S|jtju�r�|j\}}}|���}|���}tt|j|||f��St d|j�d|����)z�Recursively 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�ROUNDc3��|]}|���VqdSrf��
substituterw��symbols_maprrrz]���z"Expr.substitute.<locals>.<genexpr>c3rrfrrwrrrrz`rz?substitute: empty TERMS expression interpreted as int-literal 0rzAsubstitute: empty FACTORS expression interpreted as int-literal 1rc3rrfrr�rrrrz~r{c3s"�|]\}}||���fVqdSrfrr�rrrrzs��c3rrfrr�rrrrz�r{c3rrfrr�rrrrz�r{zsubstitute method for z: )!r�rr!rg�re�matchr��groups�as_arrayrrrr rrr|r%r�r'r�r
rrr�r(r#rvr�r$r"r)r*r&r�)rHrr��mr��parenr�r�r�r�r��targetr�r��func�operandsr�r�r�rrrr
Is�

��

�

 

zExpr.substitutecs��|g��Ri���}|dur|S|jtjtjtjtjfvr |S|jtjtjtjtj	fvrAt
t|jt���fdd�|j
D����S|jtjtjfvr�i}|j
��D]1\}}|j�g��Ri���}t|t�rr|j�g��Ri���n|}||vr~|||}|||<qQt
t|j|��S|jtjur�|j
d}t|t�r�|j�g��Ri���n|}	t���fdd�|j
dD��}
t���fdd�|j
d��D��}t
t|j|	|
|f��S|jtju�r|j
d}t|t�r�|j�g��Ri���n|}t���fd	d�|j
dd�D��}t
t|j|f|��S|jtjtjfv�r/t
t|j|j
j�g��Ri�����S|jtju�r_|j
\}
}}|j�g��Ri���}|j�g��Ri���}t
t|j|
||f��Std
|j����)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.
        Nc3�(�|]}|j�g��Ri���VqdSrf��traverserw�r�r��visitrrrz�s
��
�z Expr.traverse.<locals>.<genexpr>rc3rrfr�rx�operandrrrrz��� �rc3s0�|]\}}||j�g��Ri���fVqdSrfrr�rrrrz�s�$�rc3rrfr)rxrrrrrz�r!ztraverse method for )r�rrrrr!rr r%r"r�rr|r�r'r(r�rrvr#r�r$r)r*r&r�)rHrr�r��resultr�rirj�objrr�
kwoperands�indicesr�r�r�rrrr�sl
���

����
����z
Expr.traversecs*g}|f�fdd�	}|�|�t|�dkS)z&Check if self contains other.
        cs"|r|S|�kr|�d�|SdS)Nr)r���expr�found�r�rrr�s
�zExpr.contains.<locals>.visitr)rr})rHr�r(rrr)r�contains�s
z
Expr.containscCs t�}|fdd�}|�|�|S)z3Return a set of symbols contained in self.
        cSs|jtjur
|�|�dSdSrf)r�rr!�addr&rrrr�s�zExpr.symbols.<locals>.visit��setr)rHr(rrrr�symbols�s
zExpr.symbolscs$t�}|f�fdd�	�|���|S)zFReturn a set of expressions used as atoms in polynomial self.
        cs�|jtjur|jD]}|���q	|S|jtjtjfvrdS|jtjurBt|jdt	�rB|jdt	j
ur@|jdd���|SdS|jtjtjfvrM|S|�
|�|jtjtjfvr]|SdS)Nrr)r�rr(r�rr'rr#rvrKrSrrr+r$)r'r(�b�rrrr�s"

�z$Expr.polynomial_atoms.<locals>.visitr,)rHr(rr0r�polynomial_atoms�s
zExpr.polynomial_atomscCsz|�|td�i�}||}|�|td�i�}t|||�\}}|td�kr9td|�d|�d|�d|�d|��
��||fS)z�Return a, b such that a * symbol + b == self.

        If self is not linear with respect to symbol, raise RuntimeError.
        rrznot a z-linear equation: r�r�z == )r
r��as_numer_denom�RuntimeError)rH�symbolr/�axr��zeror�rrr�linear_solves
����zExpr.linear_solveN)*rr	r
r�staticmethodrrrur�r�r�r�r�r�r�r�r�rXrer
rIr�r�r�r�r�r�r�r�r�r�r�r�r�rrr
rr*r.r1r7rrrrr�sLB	
�)	
K8
cCs
t|t�s|S|jtjurpi}|j��D]8\}}|dkrq|jtjur-|dkr-||}d}|jtjurF|j��D]\}}t||||�q8qt|||�qt	|�dkrWt
d�St	|�dkrj|��\\}}|dkrj|Sttj|�S|jtju�rVd}i}|j��D]{\}}|dkr�q�|jtjur�t|t�r�|dkr�|||d}d}|jtj
tjfvr�|dkr�||jd9}q�|dkr�||jd|9}q�t|||�q�|jtjur�|dkr�t|t�r�|j��D]\}	}
t||	|
|�q�q�t|||�q�t|||�q�t	|�dk�s|dk�rt|t��sJ�t
|�St	|�dk�r?|��\\}}|dk�r*|}nttj|�}|dk�r7|Sttj||i�S|dk�rJttj|�Sttjttj|�|i�S|jtju�rZ|jdtju�rZ|jd\}}t|�\}}t|�\}
}t|t��r�t|t��r�t||�}||||}}n||d}}|jtju�r�|jdtju�r�|jdd|}|jdd|
|}ttj||�S|
jtju�r�|
jdtju�r�|
jdd||}|
jdd|}ttj||�Stt|�j�}t|
�j��D]\}}t|||��q�ii}}|��D]\}}|dk�r$|||<�q|||<�qtttj|��|}tttj|��|}|jtj
tjfv�rS|jddk�rS|Sttj||�S|jtju�r�|jdg}|jdd�D]W}|d}|jtju�r�|jtju�r�|jdddv�r�|jdd|jddk�r�t|jddd�|jddd�t|jd|jd��}||d<�qn|�|��qnt	|�dk�r�|dSttjt|��S|jtju�rt t|j�\}}}|jtj
u�r�|jd�r�|S|Sttj|||f�S|S)z7Normalize Expr and apply basic evaluation methods.
    rrNr�z"')!rvrr�rr'r�r�rrlr}r�r(�
integer_typesrrr�r#rKrR�
as_term_coeffrr�r�r�r�r%r�	as_stringr�r�r|r"r)r#rh�trkr�r�r�r/�e�b1�e1�dividend�divisorr�r��gr�r��lstrD�last�new_lastr�r�r�rrrr�s�
��


 
  

$$�r�cCs\t|t�rt|j|j�St|t�rt|�St|t�r tt	|��St|t
�r,t
tt|��S|S)z.Convert non-Expr objects to Expr objects.
    )
rv�complexr��real�imagr�r�rr;�reprr|rr��r#rrrr��s



r�cC�ttj|�S)zJReturn object as SYMBOL expression (variable or unparsed expression).
    )rrr!rJrrr�	as_symbol��rLr-cCsdt|t�r
ttj||f�St|t�rttj||f�St|t�r*|jtjtjfvr*|Std|�d���)z/Return object as INTEGER or REAL constant.
    �cannot convert z to INTEGER or REAL constant)	rvr~rrrr�rr�rU�r#r�rrrr��s


r�cCsDt|t�r
ttj||f�St|t�r|jtjur|Std|�d���)z'Return object as INTEGER constant.
    rNz to INTEGER constant)rvr~rrrr�rUrOrrr�
as_integer�s

rPcCs�t|t�rttjt|�|f�St|t�rttj||f�St|t�r<|jtjur)|S|jtjur<ttjt|jd�|f�St	d|�d���)z$Return object as REAL constant.
    rrNz to REAL constant)
rvr~rrrr�r�rr�rUrOrrrr��s


r�rcCsttj||f�S)zBReturn object as STRING expression (string literal constant).
    )rrrrOrrrr;�sr;cCst|t�r|f}ttj|�S)z8Return object as ARRAY expression (array constant).
    )rvrrr rJrrrr�s
rcCsttjt|�t|�f�S)zDReturn object as COMPLEX expression (complex literal constant).
    )rrrr�)rGrHrrrr��sr�cOs.ttj|ttt|��tdd�|��D��f�S)zIReturn object as APPLY expression (function call, constructor, etc.)
    csr�rfrr�rrrrz�rzas_apply.<locals>.<genexpr>)rrr#r|rr�r�r�)rr�r�rrrr��s
��r�cCsttj|||f�S)z<Return object as TERNARY expression (cond?expr1:expr2).
    )rrr")r�r�r�rrr�
as_ternary�srQcCrK)z-Return object as referencing expression.
    )rrr)�r'rrr�as_ref�rMrScCrK)z/Return object as dereferencing expression.
    )rrr*rRrrr�as_derefrMrTcC�ttjtj||f�Srf)rrr&r+r<�r�r�rrr�as_eqrsrWcCrUrf)rrr&r+r=rVrrr�as_nersrXcCrUrf)rrr&r+r>rVrrr�as_ltrsrYcCrUrf)rrr&r+r?rVrrr�as_lersrZcCrUrf)rrr&r+r@rVrrr�as_gtrsr[cCrUrf)rrr&r+rArVrrr�as_gersr\cCs�t|t�rGt|�}|jtjur|S|jtjur(ttjtd|jd�|jdi�S|jtj	ur?ttjt
d|jd�|jdi�Sttj|di�Stdt|��d���)z+Return expression as TERMS expression.
    rrrN� to terms Expr)
rvrr�r�rr'rrPr�rr�rUr�rJrrrr�#s
""r�cCs�t|t�rnt|�}|jtjur|S|jtjur?t|j�dkr?|j�	�\\}}|dkr2ttj|di�Sttj|dt�
|�di�S|jtjurf|jdtj
urf|jdsfttj|jddd|jdddi�Sttj|di�Stdt|��d���)z-Return expression as FACTORS expression.
    rrrr�rNr])rvrr�r�rr(r'r}r�r��numberr#rKrRrUr�)r#r�r�rrrr�2s"
�(r�cCs�t|t�rst|�}|jtjurtd|jd�|jdfS|jtjur/t	d|jd�|jdfS|jtj
urHt|j�dkrH|j��\\}}||fS|jtj
uro|jdtjurot|jdd�\}}ttj||jdd�|fS|dfStdt|��d���)z0Return expression as term-coefficient pair.
    rrrNz to term and coeff)rvrr�r�rrrPr�rr�r'r}r�r#rKrRr:r�rUr�)r#r�r�r<rkrrrr:Gs
r:cCs:t|t��rt|�}|jtjtjtjtjtj	tj
fvr!|td�fS|jtjurT|j
dtjurN|j
dsNtt|j
d�\}}|d|d|d|dfS|td�fS|jtjur�gg}}|j
��D]\}}t|�\}}||}|�|�|�|�qdtd�td�}}tt|��D]#}	||	}tt|��D]}
|	|
kr�|||
9}q�||7}|||	9}q�|jtjtjfvr�|j
ddkr�||}}||fS|jtju�rtd�td�}}|j
��D].\}}t|�\}
}|dkr�||
|9}|||9}q�|dk�r|||9}||
|9}q�||fStdt|��d���)z+Return expression as numer-denom pair.
    rrrrNz to numer and denom)rvrr�r�rrrrr!r$r"r�r#r�rKrRrr2r'r�r�r�r}r(rUr�)r#�numers�denomsr�r��nrhr�r��i�jr/r=�bnumer�bdenomrrrr2\sV� 

� 
�r2ccs�d}	|d7}|Vq)NrTrr)�counterrrr�_counter�s��rgcsJi��fdd�}t�djdddd�||�}d|vsJ�d	|vs!J�|�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��SINGLE�DOUBLE)�'�"rz@__f2py_QUOTES_r��@)r�COUNTER�__next__)rr�r��pri�rhrr�repl�szeliminate_quotes.<locals>.replz+({kind}_|)({single_quoted}|{double_quoted})z
\w[\w\d_]*z('([^'\\]|(\\.))*')z("([^"\\]|(\\.))*"))r��
single_quoted�
double_quotedrkrj)r�sub�format)rDrq�new_srrpr�eliminate_quotes�s
��rwcCsD|��D]\}}|d|�d��}|r|d7}|�|||�}q|S)z!Inverse of eliminate_quotes.
    Nrlr�)r��find�replace)rDrhrirjr�rrr�
insert_quotes�srzc
CsXd\}}t|�}dD]\}}|�|�}|dkrq
||kr#|}||}}q
|dur,|ifS|}|�||�}|�||d|�|�||d|�krp|�||d�}|dkr^td||�d|����|�||d|�|�||d|�ksFdd	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�NrzMismatch of z parenthesis in r
r	�CURLYr)r�r��{r{�@__f2py_PARENTHESIS_r�rl)r}rx�count�
ValueErrorrmrn�replace_parenthesis)
rDr�r��mn_i�left_�right_rbrcrorirjr�rhrrrr��s2


�$$�r�cCs |�d�s	J|��|�d�dS)Nrr�r-)�
startswith�split)rDrrr�_get_parenthesis_kind�sr�cCsZ|��D]&\}}t|�}tddddd�|}tdddd	d�|}|�||||�}q|S)
z$Inverse of replace_parenthesis.
    r�r�r~r{)r
r	r}rr�r��}r|)r�r�r�ry)rDrhrirjror�r�rrr�unreplace_parenthesis�sr�cCs4t|d��|�}t|t�r|Std|�d|�d���)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.
    rtzfailed to parse `z` to Expr instance: got `r)�_FromStringWorkerrurvrr�)rDrEr�rrrrF�s
rFc@s$eZdZdd�Zdd�Zdd�ZdS)�_PaircCs||_||_dSrfrV)rHr�r�rrrr�s
z_Pair.__init__cCs@|j|j}}t|t�r|�|�}t|t�r|�|�}t||�Srf)r�r�rvrr
r�)rHrr�r�rrrr

s




z_Pair.substitutecCs t|�j�d|j�d|j�d�Sr�)r�rr�r�r�rrrr�r�z_Pair.__repr__N)rr	r
r�r
r�rrrrr�sr�c@s4eZdZejfdd�Zdd�Zdd�Zddd	�Zd
S)r�cCsd|_d|_||_dSrf)�original�
quotes_maprErGrrrr�s
z_FromStringWorker.__init__cCst||j�Srf)rzr�)rHrDrrr�finalize_stringsz!_FromStringWorker.finalize_stringcCs||_t|�\}|_|�|�Srf)r�rwr��process)rH�inp�unquotedrrrru s
z_FromStringWorker.parser'cs�t|ttf�rt|���fdd�|D��St|t�s"Jt|�|f��t|�\}�|��}��fdd��d|vrd�|�d��}�dkrIt��|��S�dkrZt	|�dkrZt
��|��Std	��d
|����t�
d|�}|r��dkstJ����|���\}}}��|�}��|�}��|�}t|||�S�jtjur�t�
d|tj�}nt�
d
|�}|r�|��\}	}
}�jtjur�d|
d}
���|	|f��\}	}tj|
�jd�}
ttj|
|	|f�St�
d|�}|r�|��\}}
�|
�}
t|��|
��St�d|�}t	|�dk�rC���|d�pd��}t|ddd�|ddd��D]&\}}���|��}|��}|dk�r4||7}�q|dk�s;J�||8}�q|S�jtju�rad|v�ra�|�d��}ttjt��|���St�d�jtju�rm|n|�dd��}t	|�dk�rʈ|�}�jtju�r�dd�|D�}��|d�}t|ddd�|ddd��D]$\}}��|�}|��}|dk�r�||9}�q�|dk�s�J�||}�q�|S|�d��s�|�d ��r�tjtj d!�|d}���|dd���}t||�S�jtju�r$d|v�r$tt!�|�d����}��|d�}|dd�D]}��|�}||}�q|St�
d"j"d#d$d%�|�}|�rO|��\}
}}|�rE|�#��rEt$|�}t%t$|
�|�pMd&�St�
d'j"d(d)d$d*�|�}|�r�|��\}
}}}|�rr|�#��rrt$|�}|
�&�}
d+|
v�r�t't(|
�d+d,��|�p�d-�St't(|
�|�p�d&�S|�j)v�r�|d|�*d.��}t+�j)||�p�d�S|�v�r�t,|�}����|�|d/k�r�dnd�}|d/k�r�t|t��r�|S|d0v�r�t|t��r�|f}t-|�St�
d1|�}|�r?|��\}}}���|��}���|�dd2�d�}t|t��s|f}|d/k�r4t.d3d�|D��}td4d�|D��}t/|g|�Ri|��S|d5k�s;J�||St�
d6|�}|�rLt0|�S��1�|��}t2d7|�d8�j3�d9��t0|�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�|]	}��|��VqdSrf)r�)rx�s_)�contextrHrrrz0s�z,_FromStringWorker.process.<locals>.<genexpr>cs*t|ttf�rt|�t�|��St|��Srf)rv�listr|r�rr�)r�)�raw_symbols_map�restorerrr�8s
z*_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�.rtz\A(\w[\w\d_]*)\s*[=](.*)\Zz((?<!\d[edED])[+-])rrr�N�+r�z//z(?<=[@\w\d_])\s*([*]|/)�**�@__f2py_DOUBLE_STAR@cSsg|]}|�dd��qS)r�r�)ryrrrrr��s�z-_FromStringWorker.process.<locals>.<listcomp>r�r�r�)r�r�z\A({digit_string})({kind}|)\Zz\d+z_(\d+|\w[\w\d_]*))�digit_stringr�r-z7\A({significant}({exponent}|)|\d+{exponent})({kind}|)\Zz[.]\d+|\d+[.]\d*z[edED][+-]?\d+)�significantr�r�rhr=�rlr
rz4\A(.+)\s*(@__f2py_PARENTHESIS_(ROUND|SQUARE)_\d+@)\Zr�css&�|]}t|t�r|j|jfVqdSrf)rvr�r�r�r�rrrrz�s��css�|]
}t|t�s|VqdSrf)rvr�r�rrrrz�s�r	z\A\w[\w\d_]*\Zzfromstring: treating z as symbol (original=r�)4rvr�r|r�rr��stripr�r�r}r�r�rrrrQrErr
�Ir+rFrrr&r��zipr%rryr�r*r)�reversedru�isdigitr~rPrBr�r�r�rxr;r�rr�r�rLr�rrr�)rHrDr�r�rr�operr�r�r�r�r��keynamer�r"r�r r�r�rr�rr�r�r)r�r�r�rHrr�%s4
�


��&
�
��&



����

�

�
�z_FromStringWorker.processNrR)	rr	r
rrr�r�rur�rrrrr�s
r�)r-)r)r):r�__all__rro�enumr�mathrrrr+rK�	ExceptionrUrXr~r9r�r�rl�UserWarningrmrrrr�r�rLr�rPr�r;rr�r�rQrSrTrWrXrYrZr[r\r�r�r:r2rgrmrwrzr�r�r�rrFr�r�rrrr�<module>sp	

~





-+