o
    8VaE                     @   s  d Z ddlmZmZmZmZmZmZmZm	Z	m
Z
mZ ddlmZ ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZmZ dd Z dGddZ!dd Z"G dd dZ#G dd de$Z%dd Z&dd Z'dd Z(dd Z)dd Z*d d! Z+d"d# Z,e,e Z-d$d% Z.d&d' Z/d(d) Z0d*d+ Z1d,d- Z2d.d/ Z3d0d1 Z4d2d3 Z5d4d5 Z6d6d7 Z7d8d9 Z8d:d; Z9e2e1e5e6e3fZ:d<d= Z;d>d? Z<de:dd@fdAdBZ=dCdD Z>G dEdF dFej?Z@dS )HzGTransform a string with Python-like source code into SymPy expression.     )
generate_tokens
untokenize
TokenErrorNUMBERSTRINGNAMEOP	ENDMARKER
ERRORTOKENNEWLINE)	iskeywordN)StringIO)AssumptionKeys)iterable)Basic)Symbol)arityFunction)
filldedent	func_namec                 C   sF   d| v rdS z	t d|   W S  ty   Y nw t| dkr!dS dS )a  
    Predicate for whether a token name can be split into multiple tokens.

    A token is splittable if it does not contain an underscore character and
    it is not the name of a Greek letter. This is used to implicitly convert
    expressions like 'xyz' into 'x*y*z'.
    _FzGREEK SMALL LETTER    T)unicodedatalookupKeyErrorlen)token r   </usr/lib/python3/dist-packages/sympy/parsing/sympy_parser.py_token_splittable   s   r   c                 C   s4   | | d }|s| | d }t|ot|t S )z
    Predicate for whether a token name represents a callable function.

    Essentially wraps ``callable``, but looks up the token name in the
    locals and globals.
    r   )getcallable
isinstancer   )r   
local_dictglobal_dictZ	nextTokenfuncr   r   r   _token_callable)   s   r&   c                 C   s  |g ks|d d dkrt  t| ftdfg}tdfg}d}t|}t|d d d D ][\}}|\}}	|| d }
|	dkrB|d7 }n|	dkrJ|d8 }|dkr|
d dkrt||
d  d tkrt|d |
d  | ||
d d   |   S |d |
 | ||
d   |   S q+|S )Nr   ()r   )r   r   r   r   	enumerate)nameresultZ	beginningendZdifflengthindexr   toknumtokvalir   r   r   _add_factorial_tokens6   s&   

 ,$r3   c                   @   s2   e Zd ZdZdddZdd Zdd Zd	d
 ZdS )AppliedFunctionz
    A group of tokens representing a function and its arguments.

    `exponent` is for handling the shorthand sin^2, ln^2, etc.
    Nc                 C   s,   |d u rg }|| _ || _|| _g d| _d S )Nfunctionargsexponent)r6   r7   r8   items)selfr6   r7   r8   r   r   r   __init__X   s   zAppliedFunction.__init__c                 C   s    g }| | j || j |S )z1Return a list of tokens representing the function)appendr6   extendr7   )r:   r,   r   r   r   expand`   s   zAppliedFunction.expandc                 C   s   t | | j| S N)getattrr9   )r:   r/   r   r   r   __getitem__g   s   zAppliedFunction.__getitem__c                 C   s   d| j | j| jf S )NzAppliedFunction(%s, %s, %s)r5   )r:   r   r   r   __repr__j   s   
zAppliedFunction.__repr__r?   )__name__
__module____qualname____doc__r;   r>   rA   rB   r   r   r   r   r4   R   s    
r4   c                   @   s   e Zd ZdZdS )ParenthesisGroupz9List of tokens representing an expression in parentheses.N)rC   rD   rE   rF   r   r   r   r   rG   o   s    rG   c                 C   s6   g }| D ]}t |tr||  q|| q|S r?   )r"   r4   r=   r>   r<   )r,   Zresult2tokr   r   r   _flattent   s   
rI   c                        fdd}|S )Nc           
         s   g }g }d}| D ]l}|d t kre|d dkr"|tg  |d7 }nC|d dkre|d | | }t|dkrA|d | n|dd } |||}|d g| |d g }	|t|	 |d8 }q|ro|d | q|| q|r{td|S )zsGroup tokens between parentheses with ParenthesisGroup.

        Also processes those tokens recursively.

        r   r   r(   r)   r'   zMismatched parentheses)r   r<   rG   popr   r=   r   )
tokensr#   r$   r,   Zstacks
stacklevelr   stackinnerZ
parenGrouprecursorr   r   _inner   s8   
z"_group_parentheses.<locals>._innerr   )rQ   rR   r   rP   r   _group_parentheses~   s   (rS   c                 C   sz   g }d}| D ]4}|d t kr|}|| qt|tr3|r-t|||r-t|||d< d}q|| qd}|| q|S )zConvert a NAME token + ParenthesisGroup into an AppliedFunction.

    Note that ParenthesisGroups, if not applied to any function, are
    converted back into lists of tokens.

    Nr   r'   )r   r<   r"   rG   r&   r4   r=   )rL   r#   r$   r,   symbolrH   r   r   r   _apply_functions   s   
rU   c                 C   s  g }d}t | | dd D ]1\}}|| |rd}q|d tkr1|d dkr1|d tkr1d}qt|trCt|trC|tdf qt|tro|d tkro|d dkro|jd d	krg|d
 jd df|d
 _|tdf q|d tkr|d dkrt|tr|tdf q|d tkr|d dkr|d tkr|tdf q|d |d   krtkrn n|d dkr|d dkr|tdf qt|tr|d tkr|tdf q|d tkrt|||s|d tkr|d dkr|tdf q|d tkrt|||s|d tkrt|||s|tdf q|d tkr?t|||s?t|ts8|d tkr?|tdf q| rJ|| d
  |S )a  Implicitly adds '*' tokens.

    Cases:

    - Two AppliedFunctions next to each other ("sin(x)cos(x)")

    - AppliedFunction next to an open parenthesis ("sin x (cos x + 1)")

    - A close parenthesis next to an AppliedFunction ("(x+2)sin x")
    - A close parenthesis next to an open parenthesis ("(x+2)(x+3)")

    - AppliedFunction next to an implicitly applied function ("sin(x)cos x")

    Fr   Nr   .T*r(   r   r'   r   r)   )zipr<   r   r   r"   r4   r6   r&   )rL   r#   r$   r,   skiprH   nextTokr   r   r   _implicit_multiplication   s   
$




 









r[   c           	      C   s  g }d}d}d}t | | dd D ]\}}|| |d tkr<|d tttfvr<t||||r;|tdf |d7 }q|d tkrW|d tkrW|d dkrWt|||rVd}q|rt|tsj|d tkr|d dkr|d tkrv|d dks|d tkr|d dks|tdf |d7 }d}q|r|d tkr|d d	v rd}q|r|d8 }q|td
f |d8 }q| r|| d  |r|	td
fg|  |S )z+Adds parentheses as needed after functions.r   Fr   Nr(   **TrW   )^r\   rW   r)   r'   )
rX   r<   r   r   r	   r   r&   r"   r4   r=   )	rL   r#   r$   r,   ZappendParenrY   ZexponentSkiprH   rZ   r   r   r   _implicit_application  sT   
$


r^   c           	      C   s  g }g }d}d}t | | dd D ]\}}|d tkr0|d tkr0|d dkr0t|||r/d}n|r|d tkrB|d dkrBtdf}|| |d |d   krUtkren n|d d	kre|d d
kred}|d |d   krstkrn n|d dkr|d d
krd}|d= q|r|s|d tkr|d d
kr|d7 }n
|d d	kr|d8 }|dkr|| || g }q|| q| r|| d  |r|| |S )ap  Allows functions to be exponentiated, e.g. ``cos**2(x)``.

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import (parse_expr,
    ... standard_transformations, function_exponentiation)
    >>> transformations = standard_transformations + (function_exponentiation,)
    >>> parse_expr('sin**4(x)', transformations=transformations)
    sin(x)**4
    Fr   r   Nr\   Tr   r   r)   r(   rW   r'   )rX   r   r   r&   r<   r=   )	rL   r#   r$   r,   r8   Zconsuming_exponentlevelrH   rZ   r   r   r   function_exponentiation>  sH   $
88



r`   c                    rJ   )a2  Creates a transformation that splits symbol names.

    ``predicate`` should return True if the symbol name is to be split.

    For instance, to retain the default behavior but avoid splitting certain
    symbol names, a predicate like this would work:


    >>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable,
    ... standard_transformations, implicit_multiplication,
    ... split_symbols_custom)
    >>> def can_split(symbol):
    ...     if symbol not in ('list', 'of', 'unsplittable', 'names'):
    ...             return _token_splittable(symbol)
    ...     return False
    ...
    >>> transformation = split_symbols_custom(can_split)
    >>> parse_expr('unsplittable', transformations=standard_transformations +
    ... (transformation, implicit_multiplication))
    unsplittable
    c                    s  g }d}d}| D ]}|rd}qd}|d t kr |d dv r d}n|r|d t kr|d dd } |r|d d }|dd = d}	|	t|k r||	 }
|
|v sS|
|v r^|t d|
 fg n\|
 r|
g}
t|	d t|D ]}	||	  s||	d8 }	 n|
||	  qnd	|
}
|t d
ftdft d|
 ftdfg n|	t|kr|nd}|t |ftdft d|
 ftdfg |	d7 }	|	t|k sGd}d}qd}|| q|S )NFr   r   )r   r   Tr'   z%s Numberr(   z'%s'r)   r   )r   r   r=   isdigitranger<   joinr   )rL   r#   r$   r,   splitZsplit_previousrH   rT   tok_typer2   charZuse	predicater   r   _split_symbols  sV   

z,split_symbols_custom.<locals>._split_symbolsr   )rk   rl   r   rj   r   split_symbols_customr  s   8rm   c                 C   ,   t tttfD ]}|| ||} qt| } | S )a   Makes the multiplication operator optional in most cases.

    Use this before :func:`implicit_application`, otherwise expressions like
    ``sin 2x`` will be parsed as ``x * sin(2)`` rather than ``sin(2*x)``.

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import (parse_expr,
    ... standard_transformations, implicit_multiplication)
    >>> transformations = standard_transformations + (implicit_multiplication,)
    >>> parse_expr('3 x y', transformations=transformations)
    3*x*y
    )rS   implicit_multiplicationrU   r[   rI   r,   r#   r$   stepr   r   r   ro        ro   c                 C   rn   )a  Makes parentheses optional in some cases for function calls.

    Use this after :func:`implicit_multiplication`, otherwise expressions
    like ``sin 2x`` will be parsed as ``x * sin(2)`` rather than
    ``sin(2*x)``.

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import (parse_expr,
    ... standard_transformations, implicit_application)
    >>> transformations = standard_transformations + (implicit_application,)
    >>> parse_expr('cot z + csc z', transformations=transformations)
    cot(z) + csc(z)
    )rS   implicit_applicationrU   r^   rI   rp   r   r   r   rs     rr   rs   c                 C   s"   t tttfD ]}|| ||} q| S )an  Allows a slightly relaxed syntax.

    - Parentheses for single-argument method calls are optional.

    - Multiplication is implicit.

    - Symbol names can be split (i.e. spaces are not needed between
      symbols).

    - Functions can be exponentiated.

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import (parse_expr,
    ... standard_transformations, implicit_multiplication_application)
    >>> parse_expr("10sin**2 x**2 + 3xyz + tan theta",
    ... transformations=(standard_transformations +
    ... (implicit_multiplication_application,)))
    3*x*y*z + 10*sin(x**2)**2 + tan(theta)

    )split_symbolsro   rs   r`   rp   r   r   r   #implicit_multiplication_application  s
   ru   c              	   C   s  g }d}|  d t| | dd D ]\}}|\}}|\}	}
|tkr|}|dv sVt|sV|d tkr8|d dksV|d tkrL|d dv rL|	tkrL|
dksV||v r^|| dur^| t|f q||v r|dt | |
d	krwt|||< nt	|||< | t|f q||v r|| }t
|tttfst|r| t|f q|t|
d	krd
ndftd	fttt|ftdfg n| ||f ||f}q|S )zAInserts calls to ``Symbol``/``Function`` for undefined variables.)NNr   N)TrueFalseNoner   rV   )r(   ,=r(   r   r   r)   )r<   rX   r   r   r   
setdefaultsetaddr   r   r"   r   r   typer!   r=   reprstr)rL   r#   r$   r,   ZprevTokrH   rZ   tokNumtokValZ
nextTokNumZ
nextTokValr+   objr   r   r   auto_symbol  sd   





	
r   c           
      C   s  g }d}| d \}}t | }|tkr|dkr|dks&|dkr-| d d tkr-||  |S |dkr}|tdftdftdftd	ftd	fg | dd
 D ]1\}}	|tkr[|	dkr[d}	d}|si|tkri|	dv ritd|rt|d||	f qK|d||	f qK|S ||  |S )zSubstitutes "lambda" with its Sympy equivalent Lambda().
    However, the conversion doesn't take place if only "lambda"
    is passed because that is a syntax error.

    Fr   lambda      r   ZLambdar(   r)   N:ry   T)rW   r\   z)Starred arguments in lambda not supportedr'   ra   )r   r   r   r=   r   r   insert)
rL   r#   r$   r,   flagr0   r1   ZtokLenr   r   r   r   r   lambda_notationO  s8    

r   c                 C   s   g }d}| D ]@\}}|t kr#|}|dkr|d7 }qd}|t|f q|dkr-td|}n|dkr7td|}n|dkr=td}|||f q|S )z'Allows standard notation for factorial.r   !r   Z	factorialr   Z
factorial2)r
   r<   r   r3   r   )rL   r#   r$   r,   Z
nfactorialr0   r1   opr   r   r   factorial_notationw  s$   
r   c                 C   sT   g }| D ]#\}}|t kr |dkr|t df q|||f q|||f q|S )z-Treats XOR, ``^``, as exponentiation, ``**``.r]   r\   )r   r<   )rL   r#   r$   r,   r0   r1   r   r   r   convert_xor  s   r   c                 C   s  g }dd }g }| D ]G\}}|t kr\|s-d|v r-d| vr-d| vr-|||f nj||r?t|dkr?|||f nX||rYt|dkrY||d d	 rY|||f n>g }n;|tkr|d
krrt|d	krr|t|f n%|dkrt|dkr|t|f n|dkr|s|t df ng }ng }|||f |rR|d d	 dkrR|dt|  }|d d	 d\}}	|d d	 }
t|dkr|
|d d	 7 }
|dd}|	dd}	|
dd}
dt|	 }dd |	|
fD \}	}|pd}|	pdd| }}|dt|
 | }}tdftdftdft |ftdftdftdftdft |ftdft |ftdftdftdftdft |ftdft |ftdftdfg}|| g }q
|S )zw
    Allows 0.2[1] notation to represent the repeated decimal 0.2111... (19/90)

    Run this before auto_number.

    c                 S   s   t dd | D S )Nc                 s   s    | ]}|d v V  qdS )Z0123456789_Nr   ).0r2   r   r   r   	<genexpr>  s    z6repeated_decimals.<locals>.is_digit.<locals>.<genexpr>)all)sr   r   r   is_digit  s   z#repeated_decimals.<locals>.is_digitrV   ejr   r   r'   r   []z0.Nr      r   rb   0c                 S   s   g | ]}| d qS )r   )lstrip)r   wr   r   r   
<listcomp>  s    z%repeated_decimals.<locals>.<listcomp>19r(   Integerr)   +Rationalry   )	r   lowerr<   r   r   rg   replacer   r=   )rL   r#   r$   r,   r   Znumr0   r1   ZpreZpostZrepetendZzerosZ	repetendsabcdr   seqr   r   r   repeated_decimals  s~   
$
r   c           	      C   s   g }| D ]j\}}|t krg|}g }|ds|dr(|dd }tdftdfg}d|v s>d|v s4d	|v rQ|d
sQ|dsQtdftdft tt|ftdfg}ntdftdft |ftdfg}|||  q|||f q|S )z
    Converts numeric literals to use SymPy equivalents.

    Complex numbers use ``I``, integer literals use ``Integer``, and float
    literals use ``Float``.

    r   JNr'   rW   IrV   r   E0xZ0XFloatr(   r)   r   )	r   endswithr   r   
startswithr   r   r=   r<   )	rL   r#   r$   r,   r0   r1   ZnumberZpostfixr   r   r   r   auto_number  s0   r   c                 C   st   g }d}| D ]1\}}|t kr|dkrd}d}|||f q|dkr0|tkr0d}|t|f q|||f q|S )z=Converts floats into ``Rational``. Run AFTER ``auto_number``.Fr   Tr   )r   r<   r   r   )rL   r#   r$   r,   Zpassed_floatr0   r1   r   r   r   rationalize  s   r   c                 C   s~   g }t df| v r;|tdf |t df t| D ]\}}|t dfkr,|t df q|| q|t df |S | }|S )a  Transforms the equals sign ``=`` to instances of Eq.

    This is a helper function for `convert_equals_signs`.
    Works with expressions containing one equals sign and no
    nesting. Expressions like `(1=2)=False` won't work with this
    and should be used with `convert_equals_signs`.

    Examples: 1=2     to Eq(1,2)
              1*2=x   to Eq(1*2, x)

    This does not deal with function arguments yet.

    rz   ZEqr(   ry   r)   )r   r<   r   r*   )rL   r#   r$   r,   r/   r   r   r   r   _transform_equals_sign.  s   r   c                 C   rn   )as   Transforms all the equals signs ``=`` to instances of Eq.

    Parses the equals signs in the expression and replaces them with
    appropriate Eq instances.Also works with nested equals signs.

    Does not yet play well with function arguments.
    For example, the expression `(x=y)` is ambiguous and can be interpreted
    as x being an argument to a function and `convert_equals_signs` won't
    work for this.

    See also
    ========
    convert_equality_operators

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import (parse_expr,
    ... standard_transformations, convert_equals_signs)
    >>> parse_expr("1*2=x", transformations=(
    ... standard_transformations + (convert_equals_signs,)))
    Eq(2, x)
    >>> parse_expr("(1*2=x)=False", transformations=(
    ... standard_transformations + (convert_equals_signs,)))
    Eq(Eq(2, x), False)

    )rS   convert_equals_signsrU   r   rI   rp   r   r   r   r   K  s   r   c           
      C   sV   g }t |  }t|jD ]\}}}}}|||f q|D ]}	|	|||}qt|S )zt
    Converts the string ``s`` to Python code, in ``local_dict``

    Generally, ``parse_expr`` should be used.
    )r   stripr   readliner<   r   )
r   r#   r$   transformationsrL   Z
input_coder0   r1   r   Z	transformr   r   r   stringify_exprw  s   r   c                 C   s   t | ||}|S )zn
    Evaluate Python code generated by ``stringify_expr``.

    Generally, ``parse_expr`` should be used.
    )eval)coder#   r$   exprr   r   r   	eval_expr  s   r   Tc           
   
   C   s6  |du ri }n	t |tstd|du ri }td| n	t |ts%td|p(d}|rRt|s3td|D ]}t|sEttdt| t|dkrQttd	q5t	| |||}|sct
t|d
d}zt|||}|ddD ]}d||< qp|W S  ty }	 z|ddD ]}d||< q|	td|d}	~	ww )ae  Converts the string ``s`` to a SymPy expression, in ``local_dict``

    Parameters
    ==========

    s : str
        The string to parse.

    local_dict : dict, optional
        A dictionary of local variables to use when parsing.

    global_dict : dict, optional
        A dictionary of global variables. By default, this is initialized
        with ``from sympy import *``; provide this parameter to override
        this behavior (for instance, to parse ``"Q & S"``).

    transformations : tuple, optional
        A tuple of transformation functions used to modify the tokens of the
        parsed expression before evaluation. The default transformations
        convert numeric literals into their SymPy equivalents, convert
        undefined variables into SymPy symbols, and allow the use of standard
        mathematical factorial notation (e.g. ``x!``).

    evaluate : bool, optional
        When False, the order of the arguments will remain as they were in the
        string and automatic simplification that would normally occur is
        suppressed. (see examples)

    Examples
    ========

    >>> from sympy.parsing.sympy_parser import parse_expr
    >>> parse_expr("1/2")
    1/2
    >>> type(_)
    <class 'sympy.core.numbers.Half'>
    >>> from sympy.parsing.sympy_parser import standard_transformations,\
    ... implicit_multiplication_application
    >>> transformations = (standard_transformations +
    ...     (implicit_multiplication_application,))
    >>> parse_expr("2x", transformations=transformations)
    2*x

    When evaluate=False, some automatic simplifications will not occur:

    >>> parse_expr("2**3"), parse_expr("2**3", evaluate=False)
    (8, 2**3)

    In addition the order of the arguments will not be made canonical.
    This feature allows one to tell exactly how the expression was entered:

    >>> a = parse_expr('1 + x', evaluate=False)
    >>> b = parse_expr('x + 1', evaluate=0)
    >>> a == b
    False
    >>> a.args
    (1, x)
    >>> b.args
    (x, 1)

    See Also
    ========

    stringify_expr, eval_expr, standard_transformations,
    implicit_multiplication_application

    Nz!expecting local_dict to be a dictzfrom sympy import *z"expecting global_dict to be a dictr   z0`transformations` should be a list of functions.zY
                    expected a function in `transformations`,
                    not %sr   zc
                    a transformation should be function that
                    takes 3 argumentsz<string>r   z-Error from parse_expr with transformed code: )r"   dict	TypeErrorexecr   r!   r   r   r   r   compileevaluateFalser   rK   	Exception
ValueError)
r   r#   r   r$   evaluater   r   Zrvr2   r   r   r   r   
parse_expr  sJ   F



r   c                 C   s2   t | }t |}t |jd j}t |S )zO
    Replaces operators with the SymPy equivalent and sets evaluate=False.
    r   )astparseEvaluateFalseTransformervisitZ
ExpressionbodyvalueZfix_missing_locations)r   noder   r   r   r     s   

r   c                   @   s\   e Zd Zejdejdejdejdejdej	dej
dejdiZdZdd	 Zd
d Zdd ZdS )r   AddMulPowZOrZAndZNot)#ZAbsZimresignarg	conjugateZacosZacotZacscZasecZasinZatanZacoshZacothZacschZasechZasinhZatanhZcosZcotZcscZsecZsinZtanZcoshZcothZcschZsechZsinhZtanhZexpZlnlogZsqrtZcbrtc                 C   sl   g }|D ]/}t |tjr.|j}t |tjr|j}|j|kr(|| |j| q|| q|| q|S r?   )	r"   r   Callr%   idr=   flattenr7   r<   )r:   r7   r%   r,   r   Zarg_funcr   r   r   r   %  s   
z EvaluateFalseTransformer.flattenc              	   C   s  |j j| jv r| j|j j }| |j}| |j}d}t|j tjrNtj	tj
dt dtjt tdd|gtjdtjdt ddgd d d	}njt|j tjrt|jtjr||}}d
}tj	tj
dt d|tjt tddgtjdtjdt ddgd d d	}n*tj	tj
dt d|tjt tddgtjdtjdt ddgd d d	}|r||}}tj	tj
|t d||gtjdtjdt ddgd d d	}|dv r| |j||_|S |S )NFr   )r   ctxr   )r   operandr   r   r   r   r   )r%   r7   keywordsZstarargskwargsTr   )r   r   )r   	__class__	operatorsr   rightleftr"   r   Subr   NameLoadZUnaryOpZUSubZNumkeywordNameConstantDivr   r7   )r:   r   Zsympy_classr   r   Zrevnew_noder   r   r   visit_BinOp4  sX   

z$EvaluateFalseTransformer.visit_BinOpc                 C   sN   |  |}t|jtjr%|jj| jv r%|jtj	dtj
dt dd |S )Nr   Fr   r   )Zgeneric_visitr"   r%   r   r   r   	functionsr   r<   r   r   r   )r:   r   r   r   r   r   
visit_Callh  s   
$z#EvaluateFalseTransformer.visit_CallN)rC   rD   rE   r   r   ZMultr   r   r   ZBitOrZBitAndZBitXorr   r   r   r   r   r   r   r   r   r     s    
	4r   r?   )ArF   tokenizer   r   r   r   r   r   r   r	   r
   r   r   r   r   r   ior   Zsympy.assumptions.askr   Zsympy.core.compatibilityr   Zsympy.core.basicr   Z
sympy.corer   Zsympy.core.functionr   r   Zsympy.utilities.miscr   r   r   r&   r3   r4   listrG   rI   rS   rU   r[   r^   r`   rm   rt   ro   rs   ru   r   r   r   r   r   r   r   r   r   Zstandard_transformationsr   r   r   r   ZNodeTransformerr   r   r   r   r   <module>   s^    0

,H34W3(["(
q