o
    "g                     @   s  d Z dgZddlZddlZddlmZ ddlmZ G dd deZG dd	 d	eZ	G d
d deZ
G dd deZG dd deZG dd deZefZeefZdd ZG dd deZdd ZG dd dZdd Zdd Zdd Zd[d d!Zd[d"d#Zd[d$d%Zd\d'd(Zd)d* Zd]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 Z5ej6fdUdVZ7G dWdX dXZ8G dYdZ dZZ9dS )^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                   @   s   e Zd ZdZdZdZdZdS )Languagez2
    Used as Expr.tostring language argument.
    r         N)__name__
__module____qualname____doc__PythonFortranC r   r   U/var/www/html/ecg_monitoring/venv/lib/python3.10/site-packages/numpy/f2py/symbolic.pyr   $   s
    r   c                   @   sL   e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZdZdZdZdZdZdS )Opz$
    Used as Expr op attribute.
    
               (   d            i,  i  i  i  i  N)r   r	   r
   r   INTEGERREALCOMPLEXSTRINGARRAYSYMBOLTERNARYAPPLYINDEXINGCONCAT
RELATIONALTERMSFACTORSREFDEREFr   r   r   r   r   -   s"    r   c                   @   sH   e Zd ZdZdZdZdZdZdZdZ	e
ejfdd	Zejfd
dZdS )RelOpzH
    Used in Op.RELATIONAL expression to specify the function part.
    r   r               c                 C   sR   |t ju rtjtjtjtjtjtjd|	  S tjtjtjtjtjtjd| S )N).eq..ne..lt..le..gt..ge.)==!=<<=>>=)
r   r   r+   EQNELTLEGTGElower)clsslanguager   r   r   
fromstringM   s   
zRelOp.fromstringc                 C   sb   |t ju rtjdtjdtjdtjdtjdtjdi|  S tjdtjdtjd	tjd
tjdtjdi|  S )Nr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   )	r   r   r+   r<   r=   r>   r?   r@   rA   selfrE   r   r   r   tostringV   s   
zRelOp.tostringN)r   r	   r
   r   r<   r=   r>   r?   r@   rA   classmethodr   r   rF   rI   r   r   r   r   r+   B   s    r+   c                   @   s,   e Zd ZdZdZdZdZdZdZdZ	dZ
d	S )
ArithOpzC
    Used in Op.APPLY expression to specify the function part.
    r   r   r,   r-   r.   r/      N)r   r	   r
   r   POSNEGADDSUBMULDIVPOWr   r   r   r   rK   `   s    rK   c                   @      e Zd ZdS )OpErrorNr   r	   r
   r   r   r   r   rU   m       rU   c                   @   sD   e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZdZdZdZdS )
Precedencez4
    Used as Expr.tostring precedence argument.
    r   r   r   r,   r-   r/   rL      r         r   r   N)r   r	   r
   r   ATOMPOWERUNARYPRODUCTSUMr>   r<   LANDLORr"   ASSIGNTUPLENONEr   r   r   r   rX   q   s    rX   c                 C   s@   |  |}|d u r|| |< d S || }|r|| |< d S | |= d S N)get)dkvcr   r   r   
_pairs_add   s   

rl   c                   @   rT   )ExprWarningNrV   r   r   r   r   rm      rW   rm   c                 C   s   t j| tdd d S )Nr   )
stacklevel)warningswarnrm   )messager   r   r   ewarn      rr   c                   @   s$  e Zd ZdZeejfddZdd Zdd Z	dd	 Z
d
d Zdd Zdd Zdd Zdd Zdd ZejejfddZdd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.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 )Cr   zfRepresents a Fortran expression as a op-data pair.

    Expr instances are hashable and sortable.
    c                 C   s   t | |dS )z.Parse a Fortran expression to a Expr.
        rE   )rF   )rD   rE   r   r   r   parse   s   z
Expr.parsec                 C   s
  t |tsJ |tju r1t |trt|dksJ t |d ts"J t |d ttfs/J |nL|tju r[t |trAt|dksCJ t |d tsLJ t |d ttfsYJ |n"|tj	u rot |trkt|dksmJ n|tj
u rt |trt|dksJ t |d tr|d d d t|d d  dv sJ t |d ttfsJ |n|tju rt|d usJ n|tjtjfv rt |tsJ tdd |D sJ |n|tjtjfv rt |tsJ n|tju rt |trt|dksJ t|d d usJ t |d tsJ t |d tsJ nf|tju r8t |tr*t|dks,J t|d d us7J nE|tju rNt |trKt|dksMJ n/|tjtjfv r`t |ts_J n|tju rvt |trst|dksuJ ntd| || _|| _d S )	Nr   r   r   )z""z''z@@c                 s   s    | ]}t |tV  qd S rf   )
isinstancer   .0itemr   r   r   	<genexpr>       z Expr.__init__.<locals>.<genexpr>r,   z$unknown op or missing sanity check: )rv   r   r   tuplelenintstrr   floatr   r   r!   hashr    r%   allr'   r(   dictr#   r$   r"   r)   r*   r   r&   NotImplementedErroropdata)rH   r   r   r   r   r   __init__   sT   



&
  
zExpr.__init__c                 C   s"   t |to| j|ju o| j|jkS rf   )rv   r   r   r   rH   otherr   r   r   __eq__   s
   


zExpr.__eq__c                 C   sl   | j tjtjfv rtt| j }n| j tju r,| jd d tt| jd   }n| j}t	| j |fS Nr   )
r   r   r'   r(   r|   sortedr   itemsr#   r   )rH   r   r   r   r   __hash__   s   &zExpr.__hash__c                 C   s   t |trl| j|jur| jj|jjk S | jtjtjfv r.tt| j	
 tt|j	
 k S | jtju rf| j	d d |j	d d krP| j	d d |j	d d k S tt| j	d 
 tt|j	d 
 k S | j	|j	k S tS r   )rv   r   r   valuer   r'   r(   r|   r   r   r   r#   NotImplementedr   r   r   r   __lt__   s   
zExpr.__lt__c                 C   s   | |kp| |k S rf   r   r   r   r   r   __le__  s    zExpr.__le__c                 C   s
   | |k S rf   r   r   r   r   r   __gt__
     
 zExpr.__gt__c                 C   s
   | |k  S rf   r   r   r   r   r   __ge__  r   zExpr.__ge__c                 C   s    t | j d| j d| jdS N(, ))typer   r   r   rH   r   r   r   __repr__      zExpr.__repr__c                 C   s   |   S rf   )rI   r   r   r   r   __str__     zExpr.__str__c                    sb  | j tjtjfv r0| jd dk rtjntj}t| jd | jd dkr+d| jd  nd }n| j tj	u rNd
 fdd| jD }d	| d
 }tj}n| j tju r^tj}t| j}n| j tju r~| jd }| jd dkry| jd d | }tj}n| j tju rd
 fdd| jD }d| d }tj}n| j tju r
g }t| j D ]K\}}|dk rd}| }nd}|dkr|jtj d}n|tdkrt|}n| d|jtj d }|r|| n	|dkr|d || qd
|pd}|rtjntj}n| j tju rg }	g }
t| j D ]z\}}d}|dkr0|jtj d}nX tju r{|tddv rO|jtj d}d
|g| }n9|tddv ri|jtj d}|
|g|  7 }
q|jtj d}d| d| d
}n|jtj dd|  }|	r|	| |	| q|
r|	s|	dg7 }	|	dd	d
|
d
g7 }	d
|	pd}|	rtjntj}nb| j tju r| j\}}}|tju r tju r fdd|D \}}| d| }tj}n2 fdd|D }|dd | D 7 }| d	d
| d
}tj}n| j tju r=| jd } fd d| jdd! D }| dd
| d}tj}n| j tju rW fd"d| jD }d#
|}tj}n| j tj u r fd$d| jD \}}} tju r~d	| d%| d&| d
}n1 tj!u rd	| d'| d(| d
}n tj"u rd)| d| d| d
}nt#d*| j  d+  tj}no| j tj$u rd,| jjtj% d }tj%}nY| j tj&u rd-| jjtj% d }tj%}nC| j tj'u r| j\}}}|t(j)t(j*fv rtj)ntj+}|j| d}|j| d}|j d}| d.| d.| }nt#d/| j  |j,|j,k r/d	| d
 S |S )0z0Return a string representation of Expr.
        r   r   r-   _ r   c                 3        | ]}|j tj d V  qdS rt   NrI   rX   rd   rw   rt   r   r   rz         z Expr.tostring.<locals>.<genexpr>r   r   c                 3   r   r   r   rw   rt   r   r   rz   +  r   []z -  + rt    * -0r   r   izpow(z ** 1/c                       g | ]
}|j tj d qS rt   rI   rX   r_   rx   argrt   r   r   
<listcomp>k  
    
z!Expr.tostring.<locals>.<listcomp>z / c                    r   r   r   r   rt   r   r   r   q      c                 S   s$   g | ]\}}|d  | tj qS )=)rI   rX   re   rx   ri   rj   r   r   r   r   s  s    c                    r   r   r   r   rt   r   r   r   y  r   Nc                    r   r   r   r   rt   r   r   r   ~  r   z // c                    r   r   r   rx   art   r   r   r     r   ?:z if z else zmerge(ztostring for z and &* ztostring for op )-r   r   r   r   r   rX   r`   r\   r   r   joinr!   r   r    r'   r   r   rI   	as_numberr_   appendr(   r   r   rangerd   r]   r#   rK   rR   r$   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rightr   rt   r   rI     s.  


















zExpr.tostringc                 C   s   | S rf   r   r   r   r   r   __pos__  s   zExpr.__pos__c                 C   s   | d S )Nr   r   r   r   r   __neg__  r   zExpr.__neg__c           	      C   s  t |}t|tr| j|ju rk| jtjtjfv r.t| jd |jd  t	| jd |jd S | jtj
u rG| j\}}|j\}}t|| || S | jtju rkt| jt| j}|j D ]\}}t|j|| q[t|S | jtj
u r|jtjtjfv r| t| S | jtjtjfv r|jtj
u rt| | S | jtju r|jtju r| t|| jd d S | jtju r|jtju rt| |jd d| S t| t| S tS Nr   r   )kind)as_exprrv   r   r   r   r   r   r   r   maxr   
as_complexr'   r   r   rl   	normalizeas_realas_termsr   )	rH   r   r1i1r2i2r   ri   rj   r   r   r   __add__  s6   


zExpr.__add__c                 C   s   t |trt||  S tS rf   rv   number_typesr   r   r   r   r   r   __radd__     
zExpr.__radd__c                 C   s
   | |  S rf   r   r   r   r   r   __sub__  s   
zExpr.__sub__c                 C   s   t |trt||  S tS rf   r   r   r   r   r   __rsub__  r   zExpr.__rsub__c                 C   s>  t |}t|tr| j|ju r| jtjtjfv r/t| jd |jd  t	| jd |jd S | jtj
u rP| j\}}|j\}}t|| ||  || ||  S | jtju rtt| jt| j}|j D ]\}}t|j|| qdt|S | jtju rt| ji }| j D ]\}	}
|j D ]\}}t|j|	| |
|  qqt|S | jtj
u r|jtjtjfv r| t| S |jtj
u r| jtjtjfv rt| | S | jtju r|jtju r| t|| jd d S | jtju r|jtju rt| |jd d| S | jtju r| t| S |jtju rt| | S t| t| S tS r   )r   rv   r   r   r   r   r   r   r   r   r   r   r(   r   r   rl   r   r'   r   r   
as_factorsr   )rH   r   r   r   r   r   r   ri   rj   t1c1t2c2r   r   r   __mul__  sJ   

"zExpr.__mul__c                 C   s   t |trt||  S tS rf   r   r   r   r   r   __rmul__  r   zExpr.__rmul__c                 C   s   t |}t|tri|jtju rb|jd }|dkrtdS |dkr"| S |dkrO| jtju rGt| ji }| j	 D ]\}}|| |j|< q7t
|S | | |d   S |dkrZ| |  d S ttj| |iS ttj| |S tS )Nr   r   r   )r   rv   r   r   r   r   r   r   r(   r   r   as_applyrK   rS   r   )rH   r   exponentr   ri   rj   r   r   r   __pow__  s(   

zExpr.__pow__c                 C   s(   t |}t|trtttj| |S tS rf   )r   rv   r   r   r   rK   rR   r   r   r   r   r   __truediv__  s   
zExpr.__truediv__c                 C   s   t |}t|tr||  S tS rf   r   rv   r   r   r   r   r   r   __rtruediv__"     
zExpr.__rtruediv__c                 C   s*   t |}t|trtttj| |fS tS rf   )r   rv   r   r   r   r%   r   r   r   r   r   __floordiv__(  s   
zExpr.__floordiv__c                 C   s   t |}t|tr||  S tS rf   r   r   r   r   r   __rfloordiv__0  r   zExpr.__rfloordiv__c                 O   s.   t | gtt|R i tdd | D S )Nc                 s        | ]\}}|t |fV  qd S rf   r   r   r   r   r   rz   =      z Expr.__call__.<locals>.<genexpr>)r   mapr   r   r   )rH   r   r   r   r   r   __call__6  s   zExpr.__call__c                 C   sF   t |}t|ts|f}t|dkrtd| d ttj| f| S )Nr   z/C-index should be a single expression but got ``)r   rv   r|   r}   rr   r   r   r$   )rH   indexr   r   r   __getitem__?  s   
zExpr.__getitem__c                    sL  | j tju r4 | }|du r| S td| j}|r2| \}}|dv r(t|S |dks2J ||f|S | j tj	tj
tjfv rA| S | j tjtjfv rZt| j t fdd| jD S | j tju rrtt| j t fdd| jD S | j tju rd}| j D ]\}}|du r| | }q|| | 7 }q|du rtd td	S |S | j tju rd}| j D ]\}	}
|du r|	 |
 }q||	 |
 9 }q|du rtd
 tdS |S | j tju r| j\}}}t|tr| }t fdd|D }t fdd| D }tt| j |||fS | j tju rH| jd	 }t|tr-| }t fdd| jdd D }tt| j |f| S | j tju rct fdd| jD }tt| j |S | j tjtjfv rytt| j | j S | j tju r| j\}}}| }| }tt| j |||fS t d| j  d| )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ROUNDc                 3       | ]}|  V  qd S rf   
substituterw   symbols_mapr   r   rz   ]      z"Expr.substitute.<locals>.<genexpr>c                 3   r  rf   r  rw   r  r   r   rz   `  r  z?substitute: empty TERMS expression interpreted as int-literal 0r   zAsubstitute: empty FACTORS expression interpreted as int-literal 1r   c                 3   r  rf   r  r   r  r   r   rz   ~  r{   c                 3   s"    | ]\}}||  fV  qd S rf   r  r   r  r   r   rz     s    c                 3   r  rf   r  r   r  r   r   rz     r{   c                 3   r  rf   r  r   r  r   r   rz     r{   zsubstitute method for z: )!r   r   r!   rg   rematchr   groupsas_arrayr   r   r   r    r   r   r|   r%   r   r'   r   r  rr   r   r(   r#   rv   r   r$   r"   r)   r*   r&   r   )rH   r  r   mr   parenr   r   r   r   r   targetr   r   funcoperandsr   r   r   r   r  r   r  I  s   





 

zExpr.substitutec                    s  | g R i }|dur|S | j tjtjtjtjfv r | S | j tjtjtjtj	fv rAt
t| j t fdd| jD S | j tjtjfv ri }| j D ]1\}}|jg R i }t|trr|jg R i n|}||v r~|| | }|||< qQt
t| j |S | j tju r| jd }t|tr|jg R i n|}	t fdd| jd D }
t fdd| jd  D }t
t| j |	|
|fS | j tju r| jd }t|tr|jg R i n|}t fd	d| jdd D }t
t| j |f| S | j tjtjfv r/t
t| j | jjg R i S | j tju r_| j\}}}|jg R i }|jg R i }t
t| j |||fS td
| j  )aB  Traverse 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.
        Nc                 3   (    | ]}|j g R i V  qd S rf   traverserw   r   r   visitr   r   rz     s
    
z Expr.traverse.<locals>.<genexpr>r   c                 3   r  rf   r  rx   operandr  r   r   rz          r   c                 3   s0    | ]\}}||j g R i fV  qd S rf   r  r   r  r   r   rz     s    $r   c                 3   r  rf   r  )rx   r  r  r   r   rz     r!  ztraverse method for )r   r   r   r   r   r!   r   r    r%   r"   r   r   r|   r   r'   r(   r   r  rv   r#   r   r$   r)   r*   r&   r   )rH   r  r   r   resultr   ri   rj   objr  r  
kwoperandsindicesr   r   r   r   r  r   r    sl   



zExpr.traversec                    s*   g }|f fdd	}|  | t|dkS )z&Check if self contains other.
        c                    s"   |r| S |  kr| d | S d S )Nr   )r   exprfoundr   r   r   r    s   
zExpr.contains.<locals>.visitr   )r  r}   )rH   r   r(  r  r   r)  r   contains  s   
zExpr.containsc                 C   s    t  }|fdd}| | |S )z3Return a set of symbols contained in self.
        c                 S   s   | j tju r||  d S d S rf   )r   r   r!   addr&  r   r   r   r    s   zExpr.symbols.<locals>.visitsetr  )rH   r(  r  r   r   r   symbols  s   
zExpr.symbolsc                    s$   t  }|f fdd	 |   |S )zFReturn a set of expressions used as atoms in polynomial self.
        c                    s   | j tju r| jD ]}|  q	| S | j tjtjfv rd S | j tju rBt| jd t	rB| jd t	j
u r@| jd d   | S d S | j tjtjfv rM| S ||  | j tjtjfv r]| S d S )Nr   r   )r   r   r(   r   r  r'   r   r#   rv   rK   rS   r   r   r+  r$   )r'  r(  br  r   r   r    s"   

z$Expr.polynomial_atoms.<locals>.visitr,  )rH   r(  r   r0  r   polynomial_atoms  s   
zExpr.polynomial_atomsc                 C   sz   |  |tdi}| | }| |tdi}t|| | \}}|tdkr9td| d| d| d| d|  
||fS )zReturn a, b such that a * symbol + b == self.

        If self is not linear with respect to symbol, raise RuntimeError.
        r   r   znot a z-linear equation: r   r   z == )r  r   as_numer_denomRuntimeError)rH   symbolr/  axr   zeror   r   r   r   linear_solve  s   
zExpr.linear_solveN)*r   r	   r
   r   staticmethodr   r   ru   r   r   r   r   r   r   r   r   r   rX   re   r   rI   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r*  r.  r1  r7  r   r   r   r   r      sL    B	
 )	
K8c                 C   s
  t | ts| S | jtju rpi }| j D ]8\}}|dkrq|jtju r-|dkr-|| }d}|jtju rF|j D ]\}}t||||  q8qt||| qt	|dkrWt
dS t	|dkrj| \\}}|dkrj|S ttj|S | jtju rVd}i }| j D ]{\}}|dkrq|jtju rt |tr|dkr|||d   }d}|jtjtjfv r|dkr||jd 9 }q|dkr||jd | 9 }qt||| q|jtju r|dkrt |tr|j D ]\}	}
t||	|
|  qqt||| qt||| qt	|dks|dkrt |tsJ t
|S t	|dkr?| \\}}|dkr*|}nttj|}|dkr7|S ttj||iS |dkrJttj|S ttjttj||iS | jtju rZ| jd tju rZ| jd \}}t|\}}t|\}}t |trt |trt||}|| || }}n|| d}}|jtju r|jd tju r|jd d | }|jd d | | }ttj||S |jtju r|jd tju r|jd d | | }|jd d | }ttj||S tt|j}t|j D ]\}}t|||  qi i }}| D ]\}}|dkr$|||< q| ||< qtttj|| }tttj|| }|jtjtjfv rS|jd dkrS|S ttj||S | jtju r| jd g}| jdd D ]W}|d }|jtju r|jtju r|jd d dv r|jd d |jd d krt|jd dd |jd dd  t|jd |jd }||d< qn|| qnt	|dkr|d S ttjt|S | jtju rt t| j\}}}|jtju r|jd r|S |S ttj|||fS | S )z7Normalize Expr and apply basic evaluation methods.
    r   r   Nr   z"')!rv   r   r   r   r'   r   r   r   rl   r}   r   r(   integer_typesr   r   r   r#   rK   rR   as_term_coeffr   r   r   r   r   r%   r   	as_stringr   r   r|   r"   r  )r#  rh   trk   r   r   r   r/  eb1e1dividenddivisorr   r   gr   r   lstrD   lastnew_lastr   r   r   r   r   r   r     s   



 
  

$$r   c                 C   s\   t | trt| j| jS t | trt| S t | tr tt	| S t | t
r,t
tt| S | S )z.Convert non-Expr objects to Expr objects.
    )rv   complexr   realimagr   r   r   r;  reprr|   r  r   r#  r   r   r   r     s   



r   c                 C      t tj| S )zJReturn object as SYMBOL expression (variable or unparsed expression).
    )r   r   r!   rJ  r   r   r   	as_symbol     rL  r-   c                 C   sd   t | trttj| |fS t | trttj| |fS t | tr*| jtjtjfv r*| S td|  d)z/Return object as INTEGER or REAL constant.
    cannot convert z to INTEGER or REAL constant)	rv   r~   r   r   r   r   r   r   rU   r#  r   r   r   r   r     s   


r   c                 C   sD   t | trttj| |fS t | tr| jtju r| S td|  d)z'Return object as INTEGER constant.
    rN  z to INTEGER constant)rv   r~   r   r   r   r   rU   rO  r   r   r   
as_integer  s   

rP  c                 C   s   t | trttjt| |fS t | trttj| |fS t | tr<| jtju r)| S | jtju r<ttjt| jd |fS t	d|  d)z$Return object as REAL constant.
    r   rN  z to REAL constant)
rv   r~   r   r   r   r   r   r   r   rU   rO  r   r   r   r     s   


r   r   c                 C   s   t tj| |fS )zBReturn object as STRING expression (string literal constant).
    )r   r   r   rO  r   r   r   r;    s   r;  c                 C   s   t | tr| f} ttj| S )z8Return object as ARRAY expression (array constant).
    )rv   r   r   r    rJ  r   r   r   r    s   
r  c                 C   s   t tjt| t|fS )zDReturn object as COMPLEX expression (complex literal constant).
    )r   r   r   r   )rG  rH  r   r   r   r     s   r   c                 O   s.   t tj| ttt|tdd | D fS )zIReturn object as APPLY expression (function call, constructor, etc.)
    c                 s   r   rf   r   r   r   r   r   rz     r  zas_apply.<locals>.<genexpr>)r   r   r#   r|   r  r   r   r   )r  r   r   r   r   r   r     s
   r   c                 C   s   t tj| ||fS )z<Return object as TERNARY expression (cond?expr1:expr2).
    )r   r   r"   )r   r   r   r   r   r   
as_ternary  s   rQ  c                 C   rK  )z-Return object as referencing expression.
    )r   r   r)   r'  r   r   r   as_ref  rM  rS  c                 C   rK  )z/Return object as dereferencing expression.
    )r   r   r*   rR  r   r   r   as_deref  rM  rT  c                 C      t tjtj| |fS rf   )r   r   r&   r+   r<   r   r   r   r   r   as_eq  rs   rW  c                 C   rU  rf   )r   r   r&   r+   r=   rV  r   r   r   as_ne  rs   rX  c                 C   rU  rf   )r   r   r&   r+   r>   rV  r   r   r   as_lt  rs   rY  c                 C   rU  rf   )r   r   r&   r+   r?   rV  r   r   r   as_le  rs   rZ  c                 C   rU  rf   )r   r   r&   r+   r@   rV  r   r   r   as_gt  rs   r[  c                 C   rU  rf   )r   r   r&   r+   rA   rV  r   r   r   as_ge  rs   r\  c                 C   s   t | trGt| } | jtju r| S | jtju r(ttjtd| jd | jd iS | jtj	u r?ttjt
d| jd | jd iS ttj| diS tdt|  d)z+Return expression as TERMS expression.
    r   r   rN   to terms Expr)rv   r   r   r   r   r'   r   rP  r   r   r   rU   r   rJ  r   r   r   r   #  s   
""r   c                 C   s   t | trnt| } | jtju r| S | jtju r?t| jdkr?| j	 \\}}|dkr2ttj|diS ttj|dt
|diS | jtju rf| jd tju rf| jd sfttj| jd d d| jd d diS ttj| diS tdt|  d)z-Return expression as FACTORS expression.
    r   r   r   r   rN  r]  )rv   r   r   r   r   r(   r'   r}   r   r   numberr#   rK   rR   rU   r   )r#  r   r   r   r   r   r   2  s"   
(r   c                 C   s   t | trst| } | jtju rtd| jd | jd fS | jtju r/t	d| jd | jd fS | jtj
u rHt| jdkrH| j \\}}||fS | jtju ro| jd tju rot| jd d \}}ttj|| jd d |fS | dfS tdt|  d)z0Return expression as term-coefficient pair.
    r   r   rN  z to term and coeff)rv   r   r   r   r   r   rP  r   r   r   r'   r}   r   r#   rK   rR   r:  r   rU   r   )r#  r   r   r<  rk   r   r   r   r:  G  s   
r:  c                 C   s:  t | trt| } | jtjtjtjtjtj	tj
fv r!| tdfS | jtju rT| jd tju rN| jd sNtt| jd \}}|d |d  |d |d  fS | tdfS | jtju rg g }}| j D ]\}}t|\}}|| }|| || qdtdtd}}tt|D ]#}	||	 }tt|D ]}
|	|
kr|||
 9 }q||7 }|||	 9 }q|jtjtjfv r|jd dk r| | }}||fS | jtju rtdtd}}| j D ].\}}t|\}}|dkr||| 9 }||| 9 }q|dk r|||  9 }|||  9 }q||fS tdt|  d)z+Return expression as numer-denom pair.
    r   r   r   rN  z to numer and denom)rv   r   r   r   r   r   r   r   r!   r$   r"   r   r#   r   rK   rR   r  r2  r'   r   r   r   r}   r(   rU   r   )r#  numersdenomsr   r   nrh   r   r   ijr/  r=  bnumerbdenomr   r   r   r2  \  sV    

 
r2  c                  c   s    d} 	 | d7 } | V  q)Nr   Tr   r   )counterr   r   r   _counter  s   rg  c                    sJ   i   fdd}t djdddd|| }d|vsJ d	|vs!J | fS )
zgReplace quoted substrings of input string.

    Return a new string and a mapping of replacements.
    c                    s\   |   d d \}}|r|d d }ddd|d  }| d| dt  d	}| |< |S )
Nr   r   SINGLEDOUBLE)'"r   z@__f2py_QUOTES_r   @)r  COUNTER__next__)r  r   r   pri   rh   r   r   repl  s   zeliminate_quotes.<locals>.replz+({kind}_|)({single_quoted}|{double_quoted})z
\w[\w\d_]*z('([^'\\]|(\\.))*')z("([^"\\]|(\\.))*"))r   single_quoteddouble_quotedrk  rj  )r  subformat)rD   rq  new_sr   rp  r   eliminate_quotes  s   
rw  c                 C   sD   |  D ]\}}|d|d }|r|d7 }| ||| } q| S )z!Inverse of eliminate_quotes.
    Nrl  r   )r   findreplace)rD   rh   ri   rj   r   r   r   r   insert_quotes  s   rz  c                 C   sX  d\}}t | }dD ]\}}| |}|dkrq
||k r#|}||}}q
|du r,| i fS |}| ||}| ||d || ||d |krp| ||d }|dkr^td||  d| | ||d || ||d |ksFdd	d
dd| }d| dt  d}	| |t | | }
t| |t | d \}}|
||	< | d| |	 | |fS )zzReplace substrings of input that are enclosed in parenthesis.

    Return a new string and a mapping of replacements.
    )NN))(//)z()z{}z[]r   Nr   zMismatch of z parenthesis in r
  r	  CURLYr  )r   r   {r{  @__f2py_PARENTHESIS_r   rl  )r}   rx  count
ValueErrorrm  rn  replace_parenthesis)rD   r   r   mn_ileft_right_rb  rc  ro  ri   rj   r   rh   r   r   r   r    s2   


$$r  c                 C   s    |  ds	J | | dd S )Nr  r   r-   )
startswithsplit)rD   r   r   r   _get_parenthesis_kind  s   r  c                 C   sZ   |  D ]&\}}t|}tddddd| }tdddd	d| }| ||| | } q| S )
z$Inverse of replace_parenthesis.
    r   r   r~  r{  )r
  r	  r}  r  r   r   }r|  )r   r  r   ry  )rD   rh   ri   rj   ro  r   r   r   r   r   unreplace_parenthesis  s   r  c                 C   s4   t |d| }t|tr|S td|  d| d)zCreate an expression from a string.

    This is a "lazy" parser, that is, only arithmetic operations are
    resolved, non-arithmetic operations are treated as symbols.
    rt   zfailed to parse `z` to Expr instance: got `r  )_FromStringWorkerru   rv   r   r  )rD   rE   r   r   r   r   rF     s   
rF   c                   @   s$   e Zd Zdd Zdd Zdd ZdS )_Pairc                 C   s   || _ || _d S rf   rV  )rH   r   r   r   r   r   r     s   
z_Pair.__init__c                 C   s@   | j | j}}t|tr||}t|tr||}t||S rf   )r   r   rv   r   r  r  )rH   r  r   r   r   r   r   r  
  s   




z_Pair.substitutec                 C   s    t | j d| j d| j dS r   )r   r   r   r   r   r   r   r   r     r   z_Pair.__repr__N)r   r	   r
   r   r  r   r   r   r   r   r    s    r  c                   @   s4   e Zd ZejfddZdd Zdd Zddd	Zd
S )r  c                 C   s   d | _ d | _|| _d S rf   )original
quotes_maprE   rG   r   r   r   r     s   
z_FromStringWorker.__init__c                 C   s   t || jS rf   )rz  r  )rH   rD   r   r   r   finalize_string  s   z!_FromStringWorker.finalize_stringc                 C   s   || _ t|\}| _| |S rf   )r  rw  r  process)rH   inpunquotedr   r   r   ru      s   
z_FromStringWorker.parser'  c                    s  t |ttfrt| fdd|D S t |ts"J t||ft|\}| }fddd|v rd|d} dkrIt|S  dkrZt	|dkrZt
| S td	  d
| td|}|r dkstJ  | \}}}|}|}|}t|||S jtju rtd|tj}ntd|}|r| \}	}
}jtju rd|
 d }
|	|f\}	}tj|
jd}
ttj|
|	|fS td|}|r| \}}|}t||S td|}t	|dkrC|d pd}t|ddd |ddd D ]&\}}|}| }|dkr4||7 }q|dks;J ||8 }q|S jtju rad|v ra|d}ttjt|S tdjtju rm|n|dd}t	|dkrʈ|}jtjurdd |D }|d }t|ddd |ddd D ]$\}}|}| }|dkr||9 }q|dksJ || }q|S |d rtjtj d |d  }|dd }t||S jtjurd|v rtt!|d}|d }|dd D ]}|}|| }q|S td!j"d"d#d$|}|rI| \}}}|r?|# r?t$|}t%t$||pGd%S td&j"d'd(d#d)|}|r| \}}}}|rl|# rlt$|}|& }d*|v rt't(|d*d+|pd,S t't(||pd%S |j)v r|d|*d- }t+j)| |pdS |v rt,|}| |d.krdnd}|d.krt |tr|S |d/v rt |tr|f}t-|S td0|}|r9| \}}}|}|dd1 d}t |ts|f}|d.kr.t.d2d |D }td3d |D }t/|g|R i |S |d4ks5J || S td5|}|rFt0|S 1|}t2d6|d7j3 d8 t0|S )9a  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.
        c                 3   s    | ]	} | V  qd S rf   )r  )rx   s_)contextrH   r   r   rz   0  s    z,_FromStringWorker.process.<locals>.<genexpr>c                    s*   t | ttfrt| t| S t|  S rf   )rv   listr|   r   r  r  )r   )raw_symbols_maprestorer   r   r  8  s   
z*_FromStringWorker.process.<locals>.restore,r   r'  r   z&parsing comma-separated list (context=z): z\A([^?]+)[?]([^:]+)[:](.+)\Zz+\A(.+)\s*[.](eq|ne|lt|le|gt|ge)[.]\s*(.+)\Zz7\A(.+)\s*([=][=]|[!][=]|[<][=]|[<]|[>][=]|[>])\s*(.+)\Z.rt   z\A(\w[\w\d_]*)\s*[=](.*)\Zz((?<!\d[edED])[+-])r   r   r   N+r   z//z(?<=[@\w\d_])\s*([*]|/)**@__f2py_DOUBLE_STAR@c                 S   s   g | ]}| d dqS )r  r  )ry  r  r   r   r   r     s    z-_FromStringWorker.process.<locals>.<listcomp>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   rh   r=     rl  r
  r  z4\A(.+)\s*(@__f2py_PARENTHESIS_(ROUND|SQUARE)_\d+@)\Zr   c                 s   s&    | ]}t |tr|j|jfV  qd S rf   )rv   r  r   r   r   r   r   r   rz     s    c                 s   s    | ]
}t |ts|V  qd S rf   )rv   r  r   r   r   r   rz     s    r	  z\A\w[\w\d_]*\Zzfromstring: treating z as symbol (original=r   )4rv   r  r|   r   r   r  stripr  r  r}   r   r   r  r  r  rQ  rE   r   r   Ir+   rF   r   r   r&   r  zipr%   r   ry  r  r*   r)   reversedru  isdigitr~   rP  rB   r   r   r  rx  r;  r  r  r   r   rL  r  rr   r  )rH   rD   r  r   r  r  operr   r   r   r   r   keynamer   r"  r   r   r   r   r  r   r  r   r   r   )r  r  r  rH   r   r  %  s4  



&

&








z_FromStringWorker.processNrR  )	r   r	   r
   r   r   r   r  ru   r  r   r   r   r   r    s
    r  )r-   )r   )r   ):r   __all__r  ro   enumr   mathr   r   r   r+   rK   	ExceptionrU   rX   r~   r9  r   r   rl   UserWarningrm   rr   r   r   r   rL  r   rP  r   r;  r  r   r   rQ  rS  rT  rW  rX  rY  rZ  r[  r\  r   r   r:  r2  rg  rm  rw  rz  r  r  r  r   rF   r  r  r   r   r   r   <module>   sp    	    ~ 





-+