U
    L?hÛš  ã                   @  sÎ  d dl mZ d dlZd dlZd dlmZ d dlmZmZ d dlZd dlm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN d dlOmPZPmQZQ d dlRmSZS d dlTmUZU d d	lVmWZW dfd
d„ZXdd„ ZYdd„ ZZdd„ Z[e[G dd„ dƒƒZ\dS )é    )ÚannotationsN)Úproduct)ÚAnyÚCallable)FÚMulÚAddÚPowÚRationalÚlogÚexpÚsqrtÚcosÚsinÚtanÚasinÚacosÚacotÚasecÚacscÚsinhÚcoshÚtanhÚasinhÚacoshÚatanhÚacothÚasechÚacschÚexpandÚimÚflattenÚpolylogÚcancelÚexpand_trigÚsignÚsimplifyÚUnevaluatedExprÚSÚatanÚatan2ÚModÚMaxÚMinÚrfÚEiÚSiÚCiÚairyaiÚairyaiprimeÚairybiÚprimepiÚprimeÚisprimeÚcotÚsecÚcscÚcschÚsechÚcothÚFunctionÚIÚpiÚTupleÚGreaterThanÚStrictGreaterThanÚStrictLessThanÚLessThanÚEqualityÚOrÚAndÚLambdaÚIntegerÚDummyÚsymbols)ÚsympifyÚ_sympify)Úairybiprime)Úli)Úsympy_deprecation_warningc                 C  s$   t dddd t|ƒ}t| | ¡ƒS )NzóThe ``mathematica`` function for the Mathematica parser is now
deprecated. Use ``parse_mathematica`` instead.
The parameter ``additional_translation`` can be replaced by SymPy's
.replace( ) or .subs( ) methods on the output expression instead.z1.11zmathematica-parser-new)Zdeprecated_since_versionZactive_deprecations_target)rP   ÚMathematicaParserrL   Ú
_parse_old)ÚsÚadditional_translationsÚparser© rV   úK/var/www/html/venv/lib/python3.8/site-packages/sympy/parsing/mathematica.pyÚmathematica   s    úrX   c                 C  s   t ƒ }| | ¡S )a±  
    Translate a string containing a Wolfram Mathematica expression to a SymPy
    expression.

    If the translator is unable to find a suitable SymPy expression, the
    ``FullForm`` of the Mathematica expression will be output, using SymPy
    ``Function`` objects as nodes of the syntax tree.

    Examples
    ========

    >>> from sympy.parsing.mathematica import parse_mathematica
    >>> parse_mathematica("Sin[x]^2 Tan[y]")
    sin(x)**2*tan(y)
    >>> e = parse_mathematica("F[7,5,3]")
    >>> e
    F(7, 5, 3)
    >>> from sympy import Function, Max, Min
    >>> e.replace(Function("F"), lambda *x: Max(*x)*Min(*x))
    21

    Both standard input form and Mathematica full form are supported:

    >>> parse_mathematica("x*(a + b)")
    x*(a + b)
    >>> parse_mathematica("Times[x, Plus[a, b]]")
    x*(a + b)

    To get a matrix from Wolfram's code:

    >>> m = parse_mathematica("{{a, b}, {c, d}}")
    >>> m
    ((a, b), (c, d))
    >>> from sympy import Matrix
    >>> Matrix(m)
    Matrix([
    [a, b],
    [c, d]])

    If the translation into equivalent SymPy expressions fails, an SymPy
    expression equivalent to Wolfram Mathematica's "FullForm" will be created:

    >>> parse_mathematica("x_.")
    Optional(Pattern(x, Blank()))
    >>> parse_mathematica("Plus @@ {x, y, z}")
    Apply(Plus, (x, y, z))
    >>> parse_mathematica("f[x_, 3] := x^3 /; x > 0")
    SetDelayed(f(Pattern(x, Blank()), 3), Condition(x**3, x > 0))
    )rQ   Úparse)rS   rU   rV   rV   rW   Úparse_mathematica    s    2rZ   c                    s¶   t | ƒdkr„| d }tdƒ‰ | ˆ ¡}dd„ |D ƒ}t|ƒ}t|tƒrztd|› td}t|| 	‡ fdd	„t
|ƒD ƒ¡ƒS td
|ƒS t | ƒdkrª| d }| d }t||ƒS tdƒ‚d S )Né   r   ÚSlotc                 S  s   g | ]}|j d  ‘qS )r   )Úargs)Ú.0ÚarV   rV   rW   Ú
<listcomp>[   s     z#_parse_Function.<locals>.<listcomp>zdummy0:©Úclsc                   s   i | ]\}}ˆ |d  ƒ|“qS )r[   rV   )r^   ÚiÚv©r\   rV   rW   Ú
<dictcomp>_   s     
 z#_parse_Function.<locals>.<dictcomp>rV   é   z&Function node expects 1 or 2 arguments)Úlenr=   ZatomsÚmaxÚ
isinstancerI   rK   rJ   rH   ZxreplaceÚ	enumerateÚSyntaxError)r]   ÚargÚslotsÚnumbersZnumber_of_argumentsÚ	variablesÚbodyrV   re   rW   Ú_parse_FunctionV   s    

"

rr   c                 C  s   |   ¡  | S ©N)Ú_initialize_classra   rV   rV   rW   Ú_decoi   s    ru   c                G   @  sb  e Zd ZU dZdddddddd	d
dddddddddddddddœZedddƒD ]R\ZZZee e d Z	er‚de 
¡  e d Zne 
¡ e d Ze e	ei¡ qNd d!d"d#d$œZe d%ej¡d&fe d'ej¡d&fe d(ej¡d)fe d*ej¡d+fd,œZe d-ej¡Ze d.ej¡Zd/Zi Zd0ed1< i Zd0ed2< i Zd0ed3< ed4d5„ ƒZdåd7d8„Zed9d:„ ƒZd;d<„ Zd=d>„ Zed?d@„ ƒZedAdB„ ƒZ edCdD„ ƒZ!edEdF„ ƒZ"dGdH„ Z#dIdJ„ Z$dKZ%dLZ&dMZ'dNZ(dOZ)dPZ*e'd6dQdRdS„ ife%e(dQdTife%e)dUdVdWdXdYdZd[œfe%e*d\d]dS„ ife'd6d^d_ife%e*d`daife%e)dbdcddœfe%e*dedfife%e(dgdhife'd6didjdkœfe%e(dldmife%e(dndoife&d6dpdqife%e(drdsdtœfe%e(dudvdwdxdydzd{œfe%d6d|d}ife%e(d~d~dœfe%e(d€d€dœfe%e(d‚dƒife&d6d„dS„ d…dS„ d†œfe%e)d‡dˆife%e)d‰dŠd‹dŒdS„ dœfe'd6dŽddd‘d’œfe%d6d“dS„ d”dS„ d•œfe&d6d–dS„ d—dS„ d˜œfe%d6d™dšife'd6d›dS„ dœdS„ ddS„ dždS„ dŸœfe%d6d d¡dS„ ife&d6d¢d£d¤œfgZ+d¥ed¦< d§dS„ d¨dS„ d¤œZ,d©Z-dªZ.d«d"d¬d­gZ/d®d#d¯d°gZ0ed±d²„ ƒZ1ed³d´„ ƒZ2d6Z3dµd¶„ Z4d·d¸œd¹dº„Z5d»d¼d½œd¾d¿„Z6d»d¼d½œdÀdÁ„Z7d»d¼d½œdÂdÃ„Z8dÄdÅœdÆdÇ„Z9dÄdÄd¼dÈœdÉdÊ„Z:dÄdÅœdËdÌ„Z;dædÄd¼dÎœdÏdÐ„Z<d·d·dÑœdÒdÓ„Z=d·dÔœdÕdÖ„Z>dÄd×œdØdÙ„Z?e@eAeBeCdÚdS„ dÛdS„ dÜdS„ eCeDeEeFeGeHeIeJeKeLeMdÝdS„ eNeOePeQeReSeTeUeVeWeXeYeZe[e\e]e^e_je`eaebecedeeefegdÞdS„ eheiejekelemeneoepeqereseteuevewexeyeze{e|e}e~edßœFZ€ee‚dàœZƒdádâ„ Z„dãdä„ Z…d6S )çrQ   ap  
    An instance of this class converts a string of a Wolfram Mathematica
    expression to a SymPy expression.

    The main parser acts internally in three stages:

    1. tokenizer: tokenizes the Mathematica expression and adds the missing *
        operators. Handled by ``_from_mathematica_to_tokens(...)``
    2. full form list: sort the list of strings output by the tokenizer into a
        syntax tree of nested lists and strings, equivalent to Mathematica's
        ``FullForm`` expression output. This is handled by the function
        ``_from_tokens_to_fullformlist(...)``.
    3. SymPy expression: the syntax tree expressed as full form list is visited
        and the nodes with equivalent classes in SymPy are replaced. Unknown
        syntax tree nodes are cast to SymPy ``Function`` objects. This is
        handled by ``_from_fullformlist_to_sympy(...)``.

    zsqrt(x)zRational(x,y)zexp(x)zlog(x)zlog(y,x)zlog(x,2)z	log(x,10)zMod(x,y)zMax(*x)zMin(*x)zrf(x,y)z
atan2(y,x)zEi(x)zSi(x)zCi(x)z	airyai(x)zairyaiprime(x)z	airybi(x)zairybiprime(x)z li(x)z
primepi(x)zprime(x)z
isprime(x))zSqrt[x]zRational[x,y]zExp[x]zLog[x]zLog[x,y]zLog2[x]zLog10[x]zMod[x,y]zMax[*x]zMin[*x]zPochhammer[x,y]zArcTan[x,y]zExpIntegralEi[x]zSinIntegral[x]zCosIntegral[x]z	AiryAi[x]zAiryAiPrime[x]z	AiryBi[x]zAiryBiPrime[x]zLogIntegral[x]z
PrimePi[x]zPrime[x]z	PrimeQ[x])Ú ZArc)ÚSinÚCosÚTanÚCotÚSecÚCsc)rv   Úhz[x]r_   z(x)rv   z**ú[ú])ú ú^Ú{Ú}zñ
                (?:(?<=[a-zA-Z\d])|(?<=\d\.))     # a letter or a number
                \s+                               # any number of whitespaces
                (?:(?=[a-zA-Z\d])|(?=\.\d))       # a letter or a number
                Ú*zÐ
                (?:(?<=[])\d])|(?<=\d\.))       # ], ) or a number
                                                # ''
                (?=[(a-zA-Z])                   # ( or a single letter
                z¬
                (?<=[a-zA-Z])       # a letter
                \(                  # ( as a character
                (?=.)               # any characters
                z*(z¿
                (?:
                \A|(?<=[^a-zA-Z])
                )
                Pi                  # 'Pi' is 3.14159... in Mathematica
                (?=[^a-zA-Z])
                r?   )Ú
whitespaceúadd*_1úadd*_2ÚPizÞ
                (?:
                \A|(?<=[^a-zA-Z])   # at the top or a non-letter
                )
                [A-Z][a-zA-Z\d]*    # Function
                (?=\[)              # [ as a character
                z(
                \{.*\}
                zº
                (?:
                \A|(?<=[^a-zA-Z])
                )
                {arguments}         # model argument like x, y,...
                (?=[^a-zA-Z])
                z%dict[tuple[str, int], dict[str, Any]]ÚTRANSLATIONSÚcache_originalÚcache_compiledc                 C  s   |   | j¡}| j |¡ d S rs   )Ú_compile_dictionaryÚCORRESPONDENCESr‰   Úupdate)rb   ÚdrV   rV   rW   rt   ÷   s    z#MathematicaParser._initialize_classNc                 C  sl   i | _ | j  | j¡ |d kr i }| jj|krXt|tƒs>tdƒ‚|  |¡}|| j_|| j_	| j  | jj	¡ d S )NzThe argument must be dict type)
ÚtranslationsrŽ   r‰   Ú	__class__rŠ   rj   ÚdictÚ
ValueErrorrŒ   r‹   )ÚselfrT   r   rV   rV   rW   Ú__init__ý   s    

zMathematicaParser.__init__c                 C  sX  i }|  ¡ D ]D\}}|  |¡ |  |¡ |  |d¡}|  |d¡}|  |d¡}|  |d¡}| j |¡}|d kr‚dj|d}t|ƒ‚| ¡ }|  	|¡\}}	| 
¡ dks°|	t|ƒkrÄdj|d}t|ƒ‚|d d dkrÚd}
nt|ƒ}
||
f}dd	„ |D ƒ}d
d |¡ d }| jj|d}t |tj¡}i ||< ||| d< ||| d< ||| d< q|S )Nr…   r€   ú'{f}' function form is invalid.©Úfr   éÿÿÿÿr„   c                 S  s$   g | ]}|d  dkr|nd| ‘qS )r   r„   ú\rV   )r^   ÚxrV   rV   rW   r`   C  s     z9MathematicaParser._compile_dictionary.<locals>.<listcomp>z(?:(ú|z)))Ú	argumentsÚfsr]   Úpat)ÚitemsÚ_check_inputÚ_apply_rulesÚ_replaceÚ
FM_PATTERNÚsearchÚformatr“   ÚgroupÚ	_get_argsÚstartrh   ÚjoinÚARGS_PATTERN_TEMPLATEÚreÚcompileÚVERBOSE)rb   Zdicr   Úfmrž   ÚmÚerrZfm_namer]   ÚendZkey_argÚkeyZre_argsZxyzZpatStrrŸ   rV   rV   rW   rŒ     s<    

z%MathematicaParser._compile_dictionaryc           
      C  s€   | j }d}d}| |¡}|dkr*||7 }q|| ¡ }|  |¡\}}| ¡ }	|  ||||	|¡}|	}||d|… 7 }||d… }q|S )z'Parse Mathematica function to SymPy onerv   r   N)r¤   r¥   r§   r¨   r©   Ú_convert_one_function)
r”   rS   rŸ   ÚscannedÚcurr°   r¯   r]   r²   ÚbgnrV   rV   rW   Ú_convert_functionU  s    
z#MathematicaParser._convert_functionc                 C  s`  |t |ƒf| jkr<|t |ƒf}| j| d }tt||ƒƒ}n‚|df| jkrª|df}| j| d }i }t|ƒD ]:\}	}
|
d dkršd ||	d … ¡||
<  q¾||	 ||
< qlndj|d}t|ƒ‚| j| d }| j| d }d	}d}| |¡}|d kr||7 }q@| 	¡ }
| 
¡ }||d |… ||
  7 }| ¡ }||d … }qâ|d |… | ||d …  }|S )
Nr]   r„   r   ú,z'{f}' is out of the whitelist.r—   rž   rŸ   rv   )rh   r   r’   Úziprk   rª   r¦   r“   r¥   r§   r©   r²   )r”   rS   r¯   r]   r·   r²   r³   Zx_argsr   rc   r›   r±   ÚtemplaterŸ   rµ   r¶   r°   ZxbgnrV   rV   rW   r´   |  s<    

z'MathematicaParser._convert_one_functionc                 C  sÞ   |j }| ¡ d }g g  }}g }|}t||d… |ƒD ]–\}}	|	dkrh|sh|sh| |||… ¡ |d }|	dkr|| |	¡ n|	dkrŒ| ¡  |	dkr | |	¡ q6|	dkr6|r¶| ¡  q6| |||… ¡  qÎq6|d }
||
fS )z'Get arguments of a Mathematica functionr[   Nr¹   r‚   rƒ   r~   r   )Ústringr²   rk   ÚappendÚpop)rb   r°   rS   ZancZsquareZcurlyr]   r¶   rc   ÚcZfunc_endrV   rV   rW   r¨   ¾  s,    

zMathematicaParser._get_argsc                 C  s   | j | }| ||¡}|S rs   )ÚREPLACEMENTSÚreplace)rb   rS   ÚbefÚaftrV   rV   rW   r£   ä  s    
zMathematicaParser._replacec                 C  s   | j | \}}| ||¡S rs   )ÚRULESÚsub)rb   rS   rÂ   rŸ   rÃ   rV   rV   rW   r¢   ê  s    zMathematicaParser._apply_rulesc                 C  sR   dD ]4}|  |d ¡|  |d ¡krdj|d}t|ƒ‚qd|krNd}t|ƒ‚d S )N))r~   r   )r‚   rƒ   )ú(ú)r   r[   r–   r—   r‚   z Currently list is not supported.)Úcountr¦   r“   )rb   rS   Zbracketr±   rV   rV   rW   r¡   ï  s    
zMathematicaParser._check_inputc                 C  s`   |   |¡ |  |d¡}|  |d¡}|  |d¡}|  |d¡}|  |¡}|  |d¡}|  |d¡}|S )Nr…   r€   r†   r‡   r   rˆ   )r¡   r¢   r£   r¸   )r”   rS   rV   rV   rW   rR   ú  s    

zMathematicaParser._parse_oldc                 C  s"   |   |¡}|  |¡}|  |¡}|S rs   )Ú_from_mathematica_to_tokensÚ_from_tokens_to_fullformlistÚ_from_fullformlist_to_sympy)r”   rS   Ús2Zs3Zs4rV   rV   rW   rY     s    


zMathematicaParser.parseZInfixZPrefixZPostfixZFlatZRightZLeftú;c                 C  s.   t | tƒr$| r$| d dkr$| dg S d| dgS )Nr   ÚCompoundExpressionÚNull)rj   Úlist©r›   rV   rV   rW   Ú<lambda>%  ó    zMathematicaParser.<lambda>rÎ   ÚSetZ
SetDelayedZAddToZSubtractFromZTimesByZDivideBy)ú=z:=z+=z-=z*=z/=z//c                 C  s   | |gS rs   rV   ©r›   ÚyrV   rV   rW   rÒ   (  rÓ   ú&r=   z/.Z
ReplaceAllÚRuleZRuleDelayed)z->z:>z/;Ú	Conditionrœ   ZAlternativesZRepeatedZRepeatedNull)z..z...z||rF   z&&rG   ú!ÚNotZSameQZUnsameQ)z===z=!=ÚEqualZUnequalÚ	LessEqualÚLessÚGreaterEqualÚGreater)z==z!=z<=ú<z>=ú>z;;ÚSpanÚPlus©ú+ú-ÚTimes)r„   ú/Ú.ZDotc                 C  s
   t  | ¡S rs   )rQ   Ú_get_negrÑ   rV   rV   rW   rÒ   8  rÓ   c                 C  s   | S rs   rV   rÑ   rV   rV   rW   rÒ   9  rÓ   )rè   rç   r   ÚPowerÚApplyZMapZMapAllc                 C  s   d| |ddggS )Nrî   ÚListÚ1rV   rÖ   rV   rV   rW   rÒ   ;  rÓ   )z@@z/@z//@z@@@Z
DerivativeZ	FactorialZ
Factorial2Z	Decrement)ú'rÛ   z!!z--c                 C  s
   | f|•S rs   rV   rÖ   rV   rV   rW   rÒ   =  rÓ   c                 C  s   d| f|•S )NZPartrV   rÖ   rV   rV   rW   rÒ   =  rÓ   )r~   ú[[c                 C  s   d| •S )Nrï   )rï   rV   rÑ   rV   rV   rW   rÒ   >  rÓ   c                 C  s   | d S )Nr   rV   rÑ   rV   rV   rW   rÒ   >  rÓ   )r‚   rÆ   ú?ZPatternTestc                 C  s   d| dggS ©NÚPatternÚBlankrV   rÑ   rV   rV   rW   rÒ   A  rÓ   c                 C  s   dd| dgggS )NÚOptionalrõ   rö   rV   rÑ   rV   rV   rW   rÒ   B  rÓ   c                 C  s   d| dggS )Nrõ   ZBlankSequencerV   rÑ   rV   rV   rW   rÒ   C  rÓ   c                 C  s   d| dggS )Nrõ   ZBlankNullSequencerV   rÑ   rV   rV   rW   rÒ   D  rÓ   )Ú_z_.Ú__Ú___rø   c                 C  s   d| d|ggS rô   rV   rÖ   rV   rV   rW   rÒ   F  rÓ   r\   ÚSlotSequence)ú#z##z7list[tuple[str, str | None, dict[str, str | Callable]]]Ú_mathematica_op_precedencec                   C  s   ddgS )Nr\   rð   rV   rV   rV   rV   rW   rÒ   K  rÓ   c                   C  s   ddgS )Nrû   rð   rV   rV   rV   rV   rW   rÒ   L  rÓ   z[A-Za-z][A-Za-z0-9]*z (?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)rÆ   rò   r‚   rÇ   ú]]rƒ   c                 C  s,   t |tƒr"t tj|¡r"d|› S dd|gS )Nrè   ré   ú-1)rj   Ústrr¬   ÚmatchrQ   Ú_number©rb   r›   rV   rV   rW   rì   U  s    zMathematicaParser._get_negc                 C  s
   d|dgS )Nrí   rÿ   rV   r  rV   rV   rW   Ú_get_invY  s    zMathematicaParser._get_invc                 C  s¸   | j d k	r| j S | j| jg}| jd d … | jd d …  }| jD ]\}}}|D ]}| |¡ qLq>|jdd„ d | t	t
j|ƒ¡ | d¡ | d¡ t
 dd |¡ d ¡}|| _ | j S )	Nc                 S  s
   t | ƒ S rs   )rh   rÑ   rV   rV   rW   rÒ   h  rÓ   z2MathematicaParser._get_tokenizer.<locals>.<lambda>)r³   r¹   Ú
rÆ   rœ   rÇ   )Ú_regex_tokenizerÚ_literalr  Ú_enclosure_openÚ_enclosure_closerý   r½   ÚsortÚextendÚmapr¬   Úescaper­   rª   )r”   ÚtokensZtokens_escapeÚtypZstratZsymdictÚkÚ	tokenizerrV   rV   rW   Ú_get_tokenizer_  s    


z MathematicaParser._get_tokenizerr   )Úcodec                   s¤  |   ¡ ‰ g }| d¡}|dkr6t|ƒdkr¼| |¡ q¼t d||d d … ¡}|d kr^tdƒ‚|| ¡  d }|dkrˆ| |d |… ¡ | d||d |…  dd¡g¡ ||d d … }qt	|ƒD ]v\}}t
|tƒrØqÄ| d	¡}|dkrîq2| d
¡}	|	dks|	|k rtdƒ‚|d |… ||	d d …  }qØ|||< qÄ‡ fdd„|D ƒ}
dd„ |
D ƒ}|r~|d dkr~| d¡ q\|r |d dkr | d¡ q~|S )Nú"r™   r   z(?<!\\)"r[   z"mismatch in string "  " expressionZ_Strz\"z(*z*)zmismatch in comment (*  *) coderg   c                   s.   g | ]&}t |tƒr$| ¡ r$ˆ  |¡n|g‘qS rV   )rj   r   ÚisasciiÚfindall)r^   rc   ©r  rV   rW   r`   “  s     zAMathematicaParser._from_mathematica_to_tokens.<locals>.<listcomp>c                 S  s   g | ]}|D ]}|‘qqS rV   rV   )r^   rc   ÚjrV   rV   rW   r`   ”  s       r  )r  Úfindrh   r½   r¬   r¥   rl   r©   rÁ   rk   rj   rÐ   r¾   )r”   r  Zcode_splitsZstring_startZ	match_endZ
string_endrc   Z
code_splitZpos_comment_startZpos_comment_endZtoken_listsr  rV   r  rW   rÉ   p  sB    

"



z-MathematicaParser._from_mathematica_to_tokensz
str | listÚbool)ÚtokenÚreturnc                 C  s:   t |tƒrdS t | j|¡r dS t d| j |¡r6dS dS )NFz-?T)rj   rÐ   r¬   r  r  r  ©r”   r  rV   rV   rW   Ú_is_opŸ  s    
zMathematicaParser._is_opc                 C  s   |dkrdS |   |¡ S )N)rÇ   rƒ   T©r  r  rV   rV   rW   Ú_is_valid_star1¨  s    z!MathematicaParser._is_valid_star1c                 C  s   |dkrdS |   |¡ S )N)rÆ   r‚   Tr  r  rV   rV   rW   Ú_is_valid_star2­  s    z!MathematicaParser._is_valid_star2rÐ   )r  c           
      C  s~  g g}g }d}|t |ƒk rZ|| }|| jkrT|d  |¡ | |¡ | g ¡ nü|dkr°t |d ƒdkr|d d |d krtd|d  ƒ‚|  |d ¡|d< | g ¡ n || jkrB| j |¡}| j| |d kr„tdƒ}|dkr€|d dkr€|d dkr| |d	 d
¡ nb|d dkr„||d	  d
krJd||d	 < n4||d	  dkrzd||d	 < | |d d
¡ n|‚n|‚t |d ƒdkr°|d d dkr°tdƒ‚|  |d d¡}||d< g }	|d d |d krô|	 | ¡ ¡ qÌ|	 	¡  |d dkr(t |	ƒd	kr(tdt |	ƒ ƒ‚|d  |	¡ | d¡ n|d  |¡ |d	7 }qt |ƒd	krpt
dƒ‚|  |d ¡S )Nr   r™   r¹   éþÿÿÿz %s cannot be followed by comma ,zunmatched enclosurerþ   r~   r[   r   rò   rg   rÆ   z( ) not valid syntaxTz1( must be followed by one expression, %i detectedz"Stack should have only one element)rh   r  r½   rl   Ú_parse_after_bracesr	  ÚindexÚinsertr¾   ÚreverseÚRuntimeError)
r”   r  ÚstackZopen_seqÚpointerr  ÚindZunmatched_enclosureZ
last_stackZnew_stack_elementrV   rV   rW   rÊ   ²  s\    

$$
z.MathematicaParser._from_tokens_to_fullformlist)Úlinesr  Úinside_enclosurec           	      C  s  d}t |ƒ}||k r|| }|dkr|r@| |¡ |d8 }q|dkr\| d¡ |d8 }q|dkrªz|  |d |… |¡}W q² tk
r¦   | |¡ |d8 }Y qY q²X n|d }t |ƒdkrÞ|d dkrÞ| |dd … ¡ n
| |¡ t|ƒD ]}| d¡ qð||8 }d}q|d7 }qd S )Nr   r  r[   rÎ   )rh   r¾   r#  rl   r  r½   Úrange)	r”   r+  r  r,  r)  Úsizer  Z	prev_exprrc   rV   rV   rW   Ú_util_remove_newlinesé  s<    





z'MathematicaParser._util_remove_newlinesc                 C  s”   t |ƒ}d}||k r|dkr†|  ||d  ¡r†|  || ¡r†|| dkrjd||< ||d  d ||d < n| |d¡ |d7 }|d7 }|d7 }qd S )Nr   r[   rÆ   r„   )rh   r   r!  r%  )r”   r  r.  r)  rV   rV   rW   Ú_util_add_missing_asterisks  s    ÿþz-MathematicaParser._util_add_missing_asterisksF)r  r,  c                 C  s  d}g }|   |||¡ t| jƒD ]Z\}}}d|kr>|  |¡ t|ƒ}d}	|	|k r ||	 }
t|
tƒrr|
|krr||
 }t|tƒrŽ|g}d}ng }d}|
dkrÌ|| jkrÌ|	dkrÌ|  ||	d  ¡sÌ|	d7 }	qJ|| j	kr"|	dks|	|d ks|  ||	d  ¡s|  ||	d  ¡r"|	d7 }	qJd}|||	< || j	krH| 
|	d ¡}| 
|	¡}|
dkrh|  |¡}n|
dkr||  |¡}|	d8 }	|d	8 }| |¡ |}|| jkr4|	d	 |k r&|  ||	d  |
¡r&| |¡ | 
|	d ¡}| 
|	d ¡}|dkr|  |¡}n|dkr|  |¡}|d	8 }q¦| |¡ q*|| jkrª|	d	 |k rž||	d  |
krž| ||g¡ |d
 }| 
|	d ¡ | 
|	d ¡}|d	8 }q@| |¡ nœ|| jkr<|	d |k r0||	d  |
kr0t|tƒrö||| |g||< n||| |ƒ||< | 
|	d ¡ | 
|	d ¡}|d	8 }q¶| |¡ n
| |¡ nâ|| jkr¸|d k	rftdƒ‚|	|d ksˆ|  ||	d  ¡rš| j|
 ƒ ||	< n| | 
|	d ¡¡ |d8 }nr|| jkr*|d k	rÖtdƒ‚|	dksô|  ||	d  ¡r| j|
 ƒ ||	< n$| | 
|	d ¡¡ |	d8 }	|d8 }t|tƒrrt t|¡}||Ž }| ¡  t|tƒrj| |¡ n|||	< |	d7 }	qJq t|ƒdks¨t|ƒdkrÂt|ƒdkrÂ|rº|  ||¡S tdƒ‚t|ƒdkr
|d rü|d d dkrü|d dd … }d||•}|S |d S )NFr„   r   r[   ræ   Trê   rè   rg   r™   z1'Prefix' op_type should not have a grouping stratz0unable to create a single AST for the expressionrÎ   )rÎ   )r/  Úreversedrý   r0  rh   rj   r   ÚPREFIXr  ÚINFIXr¾   r  rì   r½   ÚFLATÚ_check_op_compatibleÚRIGHTÚLEFTÚ	TypeErrorÚ_missing_arguments_defaultÚPOSTFIXr   ÚtypingÚcastÚclearrÐ   r  r#  rl   )r”   r  r,  Úchangedr+  Zop_typeZgrouping_stratZop_dictr.  r)  r  Zop_nameÚnodeZfirst_indexZarg1Zarg2Znode_pZother_opZop_callÚnew_nodeZcompound_expressionrV   rV   rW   r#  !  sÆ    

,@




$



  
"

*
z%MathematicaParser._parse_after_braces)Úop1Úop2c                 C  sH   ||krdS ddh}ddh}||kr0||kr0dS ||krD||krDdS dS )NTr„   rê   rç   rè   FrV   )r”   rA  rB  ZmuldivZaddsubrV   rV   rW   r5  š  s    z&MathematicaParser._check_op_compatible)Úwmexprc           	      C  sî   g }|g}t  d|¡}d}|D ]Æ}|dkr. qæ| ¡ }|||…  dd¡ dd¡ dd¡ ¡ }| ¡ dkr‚|dkrÜ|d  |¡ nZ| ¡ dkr®|dkr¤|d  |¡ | ¡  n.| ¡ dkrÜ|d  |g¡ | |d d ¡ | ¡ }q|d S )	zH
        Parses FullForm[Downvalues[]] generated by Mathematica
        z[\[\],]r   Nr¹   rv   r   r~   r™   )	r¬   Úfinditerr©   rÁ   Ústripr§   r½   r¾   r²   )	r”   rC  Úoutr(  Ú	generatorZlast_posr  ÚpositionZ	last_exprrV   rV   rW   Ú_from_fullform_to_fullformlist¥  s*    (

z0MathematicaParser._from_fullform_to_fullformlist)Úpylistc                   s(   ddl m‰ m‰ ‡ ‡‡fdd„‰ˆ|ƒS )Nr   )r=   ÚSymbolc                   sl   t | tƒrNt| ƒdkrD| d }‡fdd„| dd … D ƒ}ˆ |ƒ|Ž S tdƒ‚nt | tƒr`ˆ| ƒS t| ƒS d S )Nr   c                   s   g | ]}ˆ |ƒ‘qS rV   rV   ©r^   rm   )Ú	converterrV   rW   r`   Ç  s     z\MathematicaParser._from_fullformlist_to_fullformsympy.<locals>.converter.<locals>.<listcomp>r[   zEmpty list of expressions)rj   rÐ   rh   r“   r   rM   )ÚexprÚheadr]   ©r=   rK  rM  rV   rW   rM  Ã  s    


zHMathematicaParser._from_fullformlist_to_fullformsympy.<locals>.converter)Úsympyr=   rK  )r”   rJ  rV   rP  rW   Ú#_from_fullformlist_to_fullformsympyÀ  s    z5MathematicaParser._from_fullformlist_to_fullformsympyc                  G  s   t t| ƒŽ S rs   )r
   r1  ©r_   rV   rV   rW   rÒ   ×  rÓ   c                 C  s
   t | dƒS ©Nrg   ©r
   rÑ   rV   rV   rW   rÒ   Ø  rÓ   c                 C  s
   t | dƒS )Né
   rU  rÑ   rV   rV   rW   rÒ   Ù  rÓ   c                  G  s    t | ƒdkrtt| ƒŽ S t| Ž S rT  )rh   r)   r1  r(   rS  rV   rV   rW   rÒ   ç  rÓ   c                  G  s   t jS rs   )r'   ZZerorS  rV   rV   rW   rÒ   	  rÓ   )Fré   rå   rí   r	   ÚLogZLog2ZLog10r	   ZExpZSqrtrw   rx   ry   rz   r{   r|   ZArcSinZArcCosZArcTanZArcCotZArcSecZArcCscZSinhZCoshZTanhZCothZSechZCschZArcSinhZArcCoshZArcTanhZArcCothZArcSechZArcCschZExpandZImZReZFlattenZPolylogZCancelZ
TrigExpandZSignZSimplifyZDeferZIdentityrÏ   r*   r+   r,   Z
PochhammerZExpIntegralEiZSinIntegralZCosIntegralZAiryAiZAiryAiPrimeZAiryBiZAiryBiPrimeZLogIntegralZPrimePiÚPrimeZPrimeQrï   rá   rà   rß   rÞ   rÝ   rF   rG   r=   )r>   rˆ   c                   s   ‡ ‡fdd„‰ ˆ |ƒS )Nc                   st   t | tƒr^t | d tƒr&ˆ | d ƒ}nˆj | d t| d ƒ¡}|‡ fdd„| dd … D ƒŽ S ˆj | t| ƒ¡S d S )Nr   c                   s   g | ]}ˆ |ƒ‘qS rV   rV   rL  )ÚrecurserV   rW   r`   3  s     zRMathematicaParser._from_fullformlist_to_sympy.<locals>.recurse.<locals>.<listcomp>r[   )rj   rÐ   Ú_node_conversionsÚgetr=   Ú_atom_conversionsrL   )rN  rO  ©rY  r”   rV   rW   rY  -  s    
z>MathematicaParser._from_fullformlist_to_sympy.<locals>.recurserV   )r”   Zfull_form_listrV   r]  rW   rË   +  s    
z-MathematicaParser._from_fullformlist_to_sympyc                 C  s,   |}| j  ¡ D ]\}}| t|ƒ|¡}q|S rs   )rZ  r    rÁ   r=   )r”   ZmformrN  Zmma_formZ
sympy_noderV   rV   rW   Ú_from_fullformsympy_to_sympy9  s    z.MathematicaParser._from_fullformsympy_to_sympy)N)F)†Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   ÚarcZtrir}   r¯   Úlowerrž   rŽ   rÀ   r¬   r­   r®   rÄ   r¤   ZARG_MTRX_PATTERNr«   r‰   Ú__annotations__rŠ   r‹   Úclassmethodrt   r•   rŒ   r¸   r´   r¨   r£   r¢   r¡   rR   rY   r3  r2  r:  r4  r6  r7  rý   r9  r  r  r  r	  rì   r  r  r  rÉ   r  r   r!  rÊ   r/  r0  r#  r5  rI  rR  r   r   r   r	   r   r   r   r   r   r7   r8   r9   r   r   r   r   r   r   r   r   r<   r;   r:   r   r   r   r   r   r   r   r   rQ  r    r!   r"   r#   r$   r%   r&   r'   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   rN   rO   r4   r5   r6   r@   rB   rA   rC   rD   rE   rF   rG   rr   rZ  r>   r?   r\  rË   r^  rV   rV   rV   rW   rQ   n   sÊ  
éÿü
üú
üú
üú
úøã)ú	þ	


?'B
%




ÿüÝ'þ

/	7#y¯UþrQ   )]Ú
__future__r   r¬   r;  Ú	itertoolsr   r   r   rQ  r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   Zsympy.core.sympifyrL   rM   Zsympy.functions.special.besselrN   Z'sympy.functions.special.error_functionsrO   Zsympy.utilities.exceptionsrP   rX   rZ   rr   ru   rQ   rV   rV   rV   rW   Ú<module>   s"   ÿ !6