U
    9%e\                  3   @  s  d Z ddlmZ ddlmZ ddlmZmZmZ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 d
dddddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<g3Zd=d>d?d@dAdBdCdDZG dEdF dFeZdLdHdIZdJdK ZdGS )Ma  
Julia code printer

The `JuliaCodePrinter` converts SymPy expressions into Julia expressions.

A complete code generator, which uses `julia_code` extensively, can be found
in `sympy.utilities.codegen`.  The `codegen` module can be used to generate
complete source code files.

    )annotations)Any)MulPowSRational)_keep_coeff)equal_valued)CodePrinter)
precedence
PRECEDENCEsearchsincostanZcotsecZcscasinacosatanZacotZasecZacscsinhcoshtanhZcothZsechZcschasinhacoshatanhZacothZasechZacschZsincatan2signfloorlogexpZcbrtsqrterferfcZerfi	factorialgammaZdigammaZtrigammaZ	polygammabetaZairyaiZairyaiprimeZairybiZairybiprimebesseljbesselyZbesseliZbesselkZerfinvZerfcinvabsceilZconjZhankelh1Zhankelh2imagreal)ZAbsZceiling	conjugateZhankel1Zhankel2imrec                	      s  e Zd ZU dZdZdZddddZdd	d
i dddddZded< i f 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 fd(d)Zd*d+ Z fd,d-Z fd.d/Z fd0d1Z fd2d3Zd4d5 Zd6d7 Zd8d9 Zd:d; Zd<d= Zd>d? Z e Z!d@dA Z"dBdC Z#dDdE Z$dFdG Z%dHdI Z&dJdK Z'dLdM Z(dNdO Z)dPdQ Z*dRdS Z+dTdU Z,dVdW Z-dXdY Z.dZd[ Z/d\d] Z0d^d_ Z1d`da Z2dbdc Z3  Z4S )dJuliaCodePrinterzD
    A printer to convert expressions to strings of Julia code.
    Z_juliaJuliaz&&z||!)andornotNauto   TF)orderZ	full_prec	precisionuser_functionsZhumanZallow_unknown_functionscontractinlinezdict[str, Any]_default_settingsc                   sH   t  | tttt| _| jtt |di }| j| d S )Nr:   )	super__init__dictzipknown_fcns_src1Zknown_functionsupdateknown_fcns_src2get)selfsettingsZ	userfuncs	__class__ S/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/printing/julia.pyr?   K   s
    zJuliaCodePrinter.__init__c                 C  s   |d S )N   rJ   )rF   prJ   rJ   rK   _rate_index_positionS   s    z%JuliaCodePrinter._rate_index_positionc                 C  s   d| S )Nz%srJ   )rF   Z
codestringrJ   rJ   rK   _get_statementW   s    zJuliaCodePrinter._get_statementc                 C  s
   d |S )Nz# {}format)rF   textrJ   rJ   rK   _get_comment[   s    zJuliaCodePrinter._get_commentc                 C  s   d ||S )Nzconst {} = {}rP   )rF   namevaluerJ   rJ   rK   _declare_number_const_   s    z&JuliaCodePrinter._declare_number_constc                 C  s
   |  |S N)indent_code)rF   linesrJ   rJ   rK   _format_codec   s    zJuliaCodePrinter._format_codec                   s    |j \ } fddt|D S )Nc                 3  s$   | ]}t  D ]}||fV  qqd S rW   )range).0jirowsrJ   rK   	<genexpr>j   s     
  z<JuliaCodePrinter._traverse_matrix_indices.<locals>.<genexpr>)shaper[   )rF   matcolsrJ   r_   rK   _traverse_matrix_indicesg   s    
z)JuliaCodePrinter._traverse_matrix_indicesc                 C  s^   g }g }|D ]H}t | j|j|jd |jd g\}}}|d|||f  |d q||fS )N   zfor %s = %s:%send)map_printlabellowerupperappend)rF   indicesZ
open_linesZclose_linesr^   varstartstoprJ   rJ   rK   _get_loop_opening_endingm   s    
z)JuliaCodePrinter._get_loop_opening_endingc                   sh  |j r0|jr0| d jr0dtj |  S t| | \}}|dk r^t| |}d}nd}g }g }g }j	dkr|
 }n
t|}|D ]}	|	jr$|	jr$|	jjr$|	jjr$|	jdkr|t|	j|	j dd nDt|	jd jd	krt|	jtr||	 |t|	j|	j  q|	jrV|	tjk	rV|	jd	krV|t|	j q||	 q|pntjg} fd
d|D }
 fdd|D }|D ]2}	|	j|krd|||	j  |||	j< qdd }|s||||
 S t|d	kr*|d j r
dnd}d||||
 ||d f S tdd |D rBdnd}d||||
 ||||f S d S )Nr   z%sim- )oldnoneF)evaluaterf   c                   s   g | ]} | qS rJ   parenthesizer\   xprecrF   rJ   rK   
<listcomp>   s     z/JuliaCodePrinter._print_Mul.<locals>.<listcomp>c                   s   g | ]} | qS rJ   ry   r{   r}   rJ   rK   r      s     (%s)c                 S  sH   |d }t dt| D ],}| |d  jr,dnd}d|||| f }q|S )Nr   rf   *z.*%s %s %s)r[   len	is_number)aa_strrr^   ZmulsymrJ   rJ   rK   multjoin   s
    z-JuliaCodePrinter._print_Mul.<locals>.multjoin/./r   c                 s  s   | ]}|j V  qd S rW   r   )r\   ZbirJ   rJ   rK   ra      s     z.JuliaCodePrinter._print_Mul.<locals>.<genexpr>z
%s %s (%s))r   Zis_imaginaryZas_coeff_Mul
is_integerri   r   ZImaginaryUnitr   r   r8   Zas_ordered_factorsr   Z	make_argsis_commutativeZis_Powr    Zis_Rationalis_negativerm   r   baser   args
isinstanceInfinityrM   r   qZOneindexall)rF   exprcer   r   bZ	pow_parenr   itemr   Zb_strr   ZdivsymrJ   r}   rK   
_print_Muly   sT    



$
 $zJuliaCodePrinter._print_Mulc                 C  s,   |  |j}|  |j}|j}d|||S )Nz{} {} {})ri   lhsrhsZrel_oprQ   )rF   r   lhs_coderhs_codeoprJ   rJ   rK   _print_Relational   s    z"JuliaCodePrinter._print_Relationalc                 C  s   t dd |jD rdnd}t|}t|jdr@d| |j S |jrt|jdrv|jjr^dnd	}d
|| |jf S t|jdr|jjrdnd	}d|| 	|j|f S d| 	|j||| 	|j|f S )Nc                 s  s   | ]}|j V  qd S rW   r   r{   rJ   rJ   rK   ra      s     z.JuliaCodePrinter._print_Pow.<locals>.<genexpr>^z.^g      ?zsqrt(%s)g      r   r   z1 %s sqrt(%s)rw   z1 %s %sr   )
r   r   r   r	   r    ri   r   r   r   rz   )rF   r   Z	powsymbolPRECsymrJ   rJ   rK   
_print_Pow   s    zJuliaCodePrinter._print_Powc                 C  s(   t |}d| |j|| |j|f S )Nz%s ^ %s)r   rz   r   r    rF   r   r   rJ   rJ   rK   _print_MatPow   s    zJuliaCodePrinter._print_MatPowc                   s   | j d rdS t |S d S )Nr<   pi	_settingsr>   Z_print_NumberSymbolrF   r   rH   rJ   rK   	_print_Pi   s    
zJuliaCodePrinter._print_Pic                 C  s   dS )Nr.   rJ   r   rJ   rJ   rK   _print_ImaginaryUnit   s    z%JuliaCodePrinter._print_ImaginaryUnitc                   s   | j d rdS t |S d S )Nr<   r   r   r   rH   rJ   rK   _print_Exp1   s    
zJuliaCodePrinter._print_Exp1c                   s   | j d rdS t |S d S )Nr<   Z
eulergammar   r   rH   rJ   rK   _print_EulerGamma   s    
z"JuliaCodePrinter._print_EulerGammac                   s   | j d rdS t |S d S )Nr<   catalanr   r   rH   rJ   rK   _print_Catalan   s    
zJuliaCodePrinter._print_Catalanc                   s   | j d rdS t |S d S )Nr<   Zgoldenr   r   rH   rJ   rK   _print_GoldenRatio  s    
z#JuliaCodePrinter._print_GoldenRatioc                 C  s   ddl m} ddlm} ddlm} |j}|j}| jd st	|j|rg }g }|j
D ]"\}	}
||||	 ||
 qT|t|| }| |S | jd r||s||r| ||S | |}| |}| d||f S d S )Nr   )
Assignment)	Piecewise)IndexedBaser<   r;   z%s = %s)Zsympy.codegen.astr   Z$sympy.functions.elementary.piecewiser   Zsympy.tensor.indexedr   r   r   r   r   r   rm   rA   ri   hasZ_doprint_loopsrO   )rF   r   r   r   r   r   r   ZexpressionsZ
conditionsr   r   tempr   r   rJ   rJ   rK   _print_Assignment
  s(    


z"JuliaCodePrinter._print_Assignmentc                 C  s   dS )NZInfrJ   r   rJ   rJ   rK   _print_Infinity'  s    z JuliaCodePrinter._print_Infinityc                 C  s   dS )Nz-InfrJ   r   rJ   rJ   rK   _print_NegativeInfinity+  s    z(JuliaCodePrinter._print_NegativeInfinityc                 C  s   dS )NNaNrJ   r   rJ   rJ   rK   
_print_NaN/  s    zJuliaCodePrinter._print_NaNc                   s    dd  fdd|D  d S )NzAny[, c                 3  s   | ]}  |V  qd S rW   ri   r\   r   rF   rJ   rK   ra   4  s     z/JuliaCodePrinter._print_list.<locals>.<genexpr>])joinr   rJ   r   rK   _print_list3  s    zJuliaCodePrinter._print_listc                 C  s2   t |dkrd| |d  S d| |d S d S )Nrf   z(%s,)r   r   r   )r   ri   	stringifyr   rJ   rJ   rK   _print_tuple7  s    zJuliaCodePrinter._print_tuplec                 C  s   dS )NtruerJ   r   rJ   rJ   rK   _print_BooleanTrue?  s    z#JuliaCodePrinter._print_BooleanTruec                 C  s   dS )NfalserJ   r   rJ   rJ   rK   _print_BooleanFalseC  s    z$JuliaCodePrinter._print_BooleanFalsec                 C  s   t | S rW   )strrk   r   rJ   rJ   rK   _print_boolG  s    zJuliaCodePrinter._print_boolc                   s   t j|jkrd|j|jf S |j|jfdkr8d|d  S |jdkrXd|j dddd S |jdkr~dd	 fd
d|D  S d|j ddddd S )Nzzeros(%s, %s))rf   rf   z[%s])r   r   rf   rt    )rowstartrowendcolsepr   c                   s   g | ]}  |qS rJ   r   r   r   rJ   rK   r   Y  s     z6JuliaCodePrinter._print_MatrixBase.<locals>.<listcomp>z;
)r   r   Zrowsepr   )r   ZZerorb   r`   rd   tabler   )rF   ArJ   r   rK   _print_MatrixBaseO  s    

 z"JuliaCodePrinter._print_MatrixBasec                 C  sr   ddl m} | }|dd |D }|dd |D }|dd |D }d| || || ||j|jf S )Nr   )Matrixc                 S  s   g | ]}|d  d qS )r   rf   rJ   r\   krJ   rJ   rK   r   b  s     z;JuliaCodePrinter._print_SparseRepMatrix.<locals>.<listcomp>c                 S  s   g | ]}|d  d  qS )rf   rJ   r   rJ   rJ   rK   r   c  s     c                 S  s   g | ]}|d  qS )   rJ   r   rJ   rJ   rK   r   d  s     zsparse(%s, %s, %s, %s, %s))Zsympy.matricesr   Zcol_listri   r`   rd   )rF   r   r   LIJZAIJrJ   rJ   rK   _print_SparseRepMatrix^  s      z'JuliaCodePrinter._print_SparseRepMatrixc                 C  s.   | j |jtd ddd|jd |jd f  S )NZAtomT)strictz[%s,%s]rf   )rz   parentr   r^   r]   r   rJ   rJ   rK   _print_MatrixElementi  s    z%JuliaCodePrinter._print_MatrixElementc                   sL    fdd}  |jd ||j|jjd  d ||j|jjd  d S )Nc                   s   | d d }| d }| d }  |}||kr2dn  |}|dkrr|dkrX||krXdS ||krd|S |d | S nd|  ||fS d S )Nr   rf   r   rg   :)ri   r   )r|   ZlimlhstepZlstrZhstrr   rJ   rK   strsliceo  s    
z5JuliaCodePrinter._print_MatrixSlice.<locals>.strslice[r   ,rf   r   )ri   r   Zrowslicerb   Zcolslice)rF   r   r   rJ   r   rK   _print_MatrixSlicen  s    z#JuliaCodePrinter._print_MatrixSlicec                   s0    fdd|j D }d |jjd|f S )Nc                   s   g | ]}  |qS rJ   r   )r\   r^   r   rJ   rK   r     s     z3JuliaCodePrinter._print_Indexed.<locals>.<listcomp>z%s[%s]r   )rn   ri   r   rj   r   )rF   r   ZindsrJ   r   rK   _print_Indexed  s    zJuliaCodePrinter._print_Indexedc                 C  s   |  |jS rW   )ri   rj   r   rJ   rJ   rK   
_print_Idx  s    zJuliaCodePrinter._print_Idxc                 C  s   d|  |jd  S )Nzeye(%s)r   )ri   rb   r   rJ   rJ   rK   _print_Identity  s    z JuliaCodePrinter._print_Identityc                   s   d  fdd jD S )Nz .* c                   s   g | ]} |t qS rJ   rz   r   r\   argr   rF   rJ   rK   r     s   z;JuliaCodePrinter._print_HadamardProduct.<locals>.<listcomp>)r   r   r   rJ   r   rK   _print_HadamardProduct  s    z'JuliaCodePrinter._print_HadamardProductc                 C  s*   t |}d| |j|| |j|gS )Nz.**)r   r   rz   r   r    r   rJ   rJ   rK   _print_HadamardPower  s
    z%JuliaCodePrinter._print_HadamardPowerc                 C  s$   |j dkrt|jS d|j|j f S )Nrf   z%s // %s)r   r   rM   r   rJ   rJ   rK   _print_Rational  s    

z JuliaCodePrinter._print_Rationalc                 C  sD   ddl m}m} |j}|tjd|  ||jtj | }| |S )Nr   )r!   r'   r   )	sympy.functionsr!   r'   argumentr   Pir8   Halfri   )rF   r   r!   r'   r|   expr2rJ   rJ   rK   	_print_jn  s    $zJuliaCodePrinter._print_jnc                 C  sD   ddl m}m} |j}|tjd|  ||jtj | }| |S )Nr   )r!   r(   r   )	r   r!   r(   r   r   r   r8   r   ri   )rF   r   r!   r(   r|   r   rJ   rJ   rK   	_print_yn  s    $zJuliaCodePrinter._print_ync           
        s   |j d jdkrtdg } jd rr fdd|j d d D }d |j d j }d|| }d	| d
 S t|j D ]\}\}}|dkr|d |  n:|t	|j d kr|dkr|d n|d |   |}	||	 |t	|j d kr||d q|d|S d S )Nrw   TzAll Piecewise expressions must contain an (expr, True) statement to be used as a default condition. Without one, the generated expression may not evaluate to anything under some condition.r<   c                   s(   g | ] \}}d   | |qS )z({}) ? ({}) :)rQ   ri   )r\   r   r   r   rJ   rK   r     s
    z5JuliaCodePrinter._print_Piecewise.<locals>.<listcomp>z (%s)
()r   zif (%s)rf   elsezelseif (%s)rg   )
r   Zcond
ValueErrorr   ri   r   r   	enumeraterm   r   )
rF   r   rY   ZecpairsZelastpwr^   r   r   Zcode0rJ   r   rK   _print_Piecewise  s*    



z!JuliaCodePrinter._print_Piecewisec                   s|      \}}d}|jr\| \}}|jr@|jr@t| | d}n|jr\|jr\t| | d}|d fdd jD  S )Nrt   rs   z * c                 3  s   | ]} |t V  qd S rW   r   r   r   rJ   rK   ra     s     z1JuliaCodePrinter._print_MatMul.<locals>.<genexpr>)Zas_coeff_mmulr   Zas_real_imagis_zeror   r   r   r   )rF   r   r   mr   r/   r.   rJ   r   rK   _print_MatMul  s    zJuliaCodePrinter._print_MatMulc           
        s   t |tr$| |d}d|S d}dd dd |D }fdd|D } fd	d|D }g }d
}t|D ]J\}}	|	dkr||	 qr||| 8 }|d|| |	f  ||| 7 }qr|S )z0Accepts a string of code or a list of code linesTrt   z    )z
^function z^if ^elseif ^else$z^for )z^end$r  r  c                 S  s   g | ]}| d qS )z 	)lstrip)r\   linerJ   rJ   rK   r     s     z0JuliaCodePrinter.indent_code.<locals>.<listcomp>c                   s&   g | ] t t fd dD qS )c                 3  s   | ]}t | V  qd S rW   r   r\   r/   r  rJ   rK   ra     s     :JuliaCodePrinter.indent_code.<locals>.<listcomp>.<genexpr>intanyr\   )	inc_regexr  rK   r     s   c                   s&   g | ] t t fd dD qS )c                 3  s   | ]}t | V  qd S rW   r   r  r  rJ   rK   ra     s     r  r	  r  )	dec_regexr  rK   r     s   r   )rt   r   z%s%s)r   r   rX   
splitlinesr   r   rm   )
rF   codeZ
code_linestabZincreaseZdecreaseprettylevelnr  rJ   )r  r  rK   rX     s.    




zJuliaCodePrinter.indent_code)5__name__
__module____qualname____doc__Zprintmethodlanguage
_operatorsr=   __annotations__r?   rN   rO   rS   rV   rZ   re   rr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Z_print_Tupler   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rX   __classcell__rJ   rJ   rH   rK   r0   0   sv   
J$r0   Nc                 K  s   t || |S )a)  Converts `expr` to a string of Julia code.

    Parameters
    ==========

    expr : Expr
        A SymPy expression to be converted.
    assign_to : optional
        When given, the argument is used as the name of the variable to which
        the expression is assigned.  Can be a string, ``Symbol``,
        ``MatrixSymbol``, or ``Indexed`` type.  This can be helpful for
        expressions that generate multi-line statements.
    precision : integer, optional
        The precision for numbers such as pi  [default=16].
    user_functions : dict, optional
        A dictionary where keys are ``FunctionClass`` instances and values are
        their string representations.  Alternatively, the dictionary value can
        be a list of tuples i.e. [(argument_test, cfunction_string)].  See
        below for examples.
    human : bool, optional
        If True, the result is a single string that may contain some constant
        declarations for the number symbols.  If False, the same information is
        returned in a tuple of (symbols_to_declare, not_supported_functions,
        code_text).  [default=True].
    contract: bool, optional
        If True, ``Indexed`` instances are assumed to obey tensor contraction
        rules and the corresponding nested loops over indices are generated.
        Setting contract=False will not generate loops, instead the user is
        responsible to provide values for the indices in the code.
        [default=True].
    inline: bool, optional
        If True, we try to create single-statement code instead of multiple
        statements.  [default=True].

    Examples
    ========

    >>> from sympy import julia_code, symbols, sin, pi
    >>> x = symbols('x')
    >>> julia_code(sin(x).series(x).removeO())
    'x .^ 5 / 120 - x .^ 3 / 6 + x'

    >>> from sympy import Rational, ceiling
    >>> x, y, tau = symbols("x, y, tau")
    >>> julia_code((2*tau)**Rational(7, 2))
    '8 * sqrt(2) * tau .^ (7 // 2)'

    Note that element-wise (Hadamard) operations are used by default between
    symbols.  This is because its possible in Julia to write "vectorized"
    code.  It is harmless if the values are scalars.

    >>> julia_code(sin(pi*x*y), assign_to="s")
    's = sin(pi * x .* y)'

    If you need a matrix product "*" or matrix power "^", you can specify the
    symbol as a ``MatrixSymbol``.

    >>> from sympy import Symbol, MatrixSymbol
    >>> n = Symbol('n', integer=True, positive=True)
    >>> A = MatrixSymbol('A', n, n)
    >>> julia_code(3*pi*A**3)
    '(3 * pi) * A ^ 3'

    This class uses several rules to decide which symbol to use a product.
    Pure numbers use "*", Symbols use ".*" and MatrixSymbols use "*".
    A HadamardProduct can be used to specify componentwise multiplication ".*"
    of two MatrixSymbols.  There is currently there is no easy way to specify
    scalar symbols, so sometimes the code might have some minor cosmetic
    issues.  For example, suppose x and y are scalars and A is a Matrix, then
    while a human programmer might write "(x^2*y)*A^3", we generate:

    >>> julia_code(x**2*y*A**3)
    '(x .^ 2 .* y) * A ^ 3'

    Matrices are supported using Julia inline notation.  When using
    ``assign_to`` with matrices, the name can be specified either as a string
    or as a ``MatrixSymbol``.  The dimensions must align in the latter case.

    >>> from sympy import Matrix, MatrixSymbol
    >>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
    >>> julia_code(mat, assign_to='A')
    'A = [x .^ 2 sin(x) ceil(x)]'

    ``Piecewise`` expressions are implemented with logical masking by default.
    Alternatively, you can pass "inline=False" to use if-else conditionals.
    Note that if the ``Piecewise`` lacks a default term, represented by
    ``(expr, True)`` then an error will be thrown.  This is to prevent
    generating an expression that may not evaluate to anything.

    >>> from sympy import Piecewise
    >>> pw = Piecewise((x + 1, x > 0), (x, True))
    >>> julia_code(pw, assign_to=tau)
    'tau = ((x > 0) ? (x + 1) : (x))'

    Note that any expression that can be generated normally can also exist
    inside a Matrix:

    >>> mat = Matrix([[x**2, pw, sin(x)]])
    >>> julia_code(mat, assign_to='A')
    'A = [x .^ 2 ((x > 0) ? (x + 1) : (x)) sin(x)]'

    Custom printing can be defined for certain types by passing a dictionary of
    "type" : "function" to the ``user_functions`` kwarg.  Alternatively, the
    dictionary value can be a list of tuples i.e., [(argument_test,
    cfunction_string)].  This can be used to call a custom Julia function.

    >>> from sympy import Function
    >>> f = Function('f')
    >>> g = Function('g')
    >>> custom_functions = {
    ...   "f": "existing_julia_fcn",
    ...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
    ...         (lambda x: not x.is_Matrix, "my_fcn")]
    ... }
    >>> mat = Matrix([[1, x]])
    >>> julia_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
    'existing_julia_fcn(x) + my_fcn(x) + my_mat_fcn([1 x])'

    Support for loops is provided through ``Indexed`` types. With
    ``contract=True`` these expressions will be turned into loops, whereas
    ``contract=False`` will just print the assignment expression that should be
    looped over:

    >>> from sympy import Eq, IndexedBase, Idx
    >>> len_y = 5
    >>> y = IndexedBase('y', shape=(len_y,))
    >>> t = IndexedBase('t', shape=(len_y,))
    >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
    >>> i = Idx('i', len_y-1)
    >>> e = Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
    >>> julia_code(e.rhs, assign_to=e.lhs, contract=False)
    'Dy[i] = (y[i + 1] - y[i]) ./ (t[i + 1] - t[i])'
    )r0   Zdoprint)r   Z	assign_torG   rJ   rJ   rK   
julia_code  s     r  c                 K  s   t t| f| dS )z~Prints the Julia representation of the given expression.

    See `julia_code` for the meaning of the optional arguments.
    N)printr  )r   rG   rJ   rJ   rK   print_julia_code  s    r  )N)r  
__future__r   typingr   Z
sympy.corer   r   r   r   Zsympy.core.mulr   Zsympy.core.numbersr	   Zsympy.printing.codeprinterr
   Zsympy.printing.precedencer   r   r/   r   rB   rD   r0   r  r  rJ   rJ   rJ   rK   <module>   s                                         W
 
