
    Xh[                        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 g d
ZddddddddZ G d de          ZddZd ZdS )a  
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)2sincostancotseccscasinacosatanacotasecacscsinhcoshtanhcothsechcschasinhacoshatanhacothasechacschatan2signfloorlogexpcbrtsqrterferfcerfi	factorialgammadigammatrigamma	polygammabetaairyaiairyaiprimeairybiairybiprimebesseljbesselybesselibesselkerfinverfcinvabsceilconjhankelh1hankelh2imagreal)Absceiling	conjugatehankel1hankel2imrec            	      z    e Zd ZU dZdZdZddddZ eej	        fi di d	d	d
Z	de
d<   i f fd	Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z fdZd Z fdZ fdZ fdZ fdZd Zd  Zd! Zd" Z d# Z!d$ Z"e"Z#d% Z$d& Z%d' Z&d( Z'd) Z(d* Z)d+ Z*d, Z+d- Z,d. Z-d/ Z.d0 Z/d1 Z0d2 Z1d3 Z2d4 Z3d5 Z4d6 Z5 xZ6S )7JuliaCodePrinterzD
    A printer to convert expressions to strings of Julia code.
    _juliaJuliaz&&z||!)andornot   T)	precisionuser_functionscontractinlinezdict[str, Any]_default_settingsc                Z   t                                          |           t          t          t          t                              | _        | j                            t          t                               |                    di           }| j                            |           d S )NrZ   )	super__init__dictzipknown_fcns_src1known_functionsupdateknown_fcns_src2get)selfsettings	userfuncs	__class__s      f/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/sympy/printing/julia.pyr`   zJuliaCodePrinter.__init__G   s    """#C$I$IJJ##D$9$9:::LL!1266	##I.....    c                    |dz  S )N    )rh   ps     rl   _rate_index_positionz%JuliaCodePrinter._rate_index_positionO   s    s
rm   c                    d|z  S )Nz%srp   )rh   
codestrings     rl   _get_statementzJuliaCodePrinter._get_statementS   s    j  rm   c                ,    d                     |          S )Nz# {}format)rh   texts     rl   _get_commentzJuliaCodePrinter._get_commentW   s    }}T"""rm   c                .    d                     ||          S )Nzconst {} = {}rw   )rh   namevalues      rl   _declare_number_constz&JuliaCodePrinter._declare_number_const[   s    %%dE222rm   c                ,    |                      |          S N)indent_code)rh   liness     rl   _format_codezJuliaCodePrinter._format_code_   s    &&&rm   c                N    |j         \  }fdt          |          D             S )Nc              3  D   K   | ]}t                    D ]}||fV  	d S r   )range).0jirowss      rl   	<genexpr>z<JuliaCodePrinter._traverse_matrix_indices.<locals>.<genexpr>f   s:      AA1U4[[AAAAAAAAAArm   )shaper   )rh   matcolsr   s      @rl   _traverse_matrix_indicesz)JuliaCodePrinter._traverse_matrix_indicesc   s.    Y
dAAAAdAAAArm   c           	         g }g }|D ]f}t          | j        |j        |j        dz   |j        dz   g          \  }}}|                    d|d|d|           |                    d           g||fS )N   zfor  = :end)map_printlabellowerupperappend)rh   indices
open_linesclose_linesr   varstartstops           rl   _get_loop_opening_endingz)JuliaCodePrinter._get_loop_opening_endingi   s    
 	& 	&A"4;Wagk17Q;7 9  9C###uuuddCDDDu%%%%;&&rm   c                J    |j         rL|j        rE|                                d         j        r&d                     t
          j         |z            z  S t          |          |                                \  }}|dk     rt          | |          }d}nd}g }g }g } j	        dvr|
                                }nt          j        |          }|D ]D}	|	j        r|	j        r|	j        j        r|	j        j        r|	j        dk    r1|                    t'          |	j        |	j         d                     et+          |	j        d         j                  d	k    r/t/          |	j        t                    r|                    |	           |                    t'          |	j        |	j                              |	j        rB|	t
          j        ur4|	j        d	k    r)|                    t5          |	j                             /|                    |	           F|pt
          j        g} fd
|D             }
 fd|D             }|D ]I}	|	j        |v r>d||                    |	j                           z  ||                    |	j                  <   Jd }|s| |||
          z   S t+          |          d	k    r.|d         j         rdnd}| |||
          z   d|d|d         S t=          d |D                       rdnd}| |||
          z   d|d |||          dS )Nr   z%sim- )oldnoneF)evaluater   c                <    g | ]}                     |          S rp   parenthesizer   xprecrh   s     rl   
<listcomp>z/JuliaCodePrinter._print_Mul.<locals>.<listcomp>   )    777""1d++777rm   c                <    g | ]}                     |          S rp   r   r   s     rl   r   z/JuliaCodePrinter._print_Mul.<locals>.<listcomp>   r   rm   (%s)c                    |d         }t          dt          |                     D ]&}| |dz
           j        rdnd}|d|d||         }'|S )Nr   r   *z.* )r   len	is_number)aa_strrr   mulsyms        rl   multjoinz-JuliaCodePrinter._print_Mul.<locals>.multjoin   sd    aA1c!ff%% 7 7 !!A# 0:d"#!!VVVU1XX6Hrm   /./r   c              3  $   K   | ]}|j         V  d S r   r   )r   bis     rl   r   z.JuliaCodePrinter._print_Mul.<locals>.<genexpr>   s$      99999999rm   z ())r   is_imaginaryas_coeff_Mul
is_integerr   r   ImaginaryUnitr   r	   orderas_ordered_factorsr   	make_argsis_commutativeis_Powr,   is_Rationalis_negativer   r   baser   args
isinstanceInfinityrq   r   qOneindexall)rh   exprcer)   r   b	pow_parenr   itemr   b_strr   divsymr   s   `             @rl   
_print_MulzJuliaCodePrinter._print_Mulu   s   N 	?t0 	?!!##A&1	?DKK(8(=>>>> $  ""1q55r1%%DDDD	:_,,**,,DD =&&D  	 	D#  8L ,8r>>HHSTXIFFFGGGG49Q<,--22z$)S7Q7Q2!((...HHSTXI667777! d!*&<&<1
 $&))****L!%77777Q77777777Q777  	O 	ODyA~~,2U17749;M;M5N,Naggdi(()	 	 	  	Z((1e,,,,VVq[[aDN4SSF!%hhq%&8&8!8!8!8&&&%((KK99q99999CSStF#'((1e*<*<#<#<#<fffhhqRWFXFXFXFXYYrm   c                    |                      |j                  }|                      |j                  }|j        }d                    |||          S )Nz{} {} {})r   lhsrhsrel_oprx   )rh   r   lhs_coderhs_codeops        rl   _print_Relationalz"JuliaCodePrinter._print_Relational   sG    ;;tx((;;tx(([  2x888rm   c                f   t          d |j        D                       rdnd}t          |          }t          |j        d          rd|                     |j                  z  S |j        rt          |j        d          r1|j        j        rdnd}d	|d
|                     |j                  dS t          |j        d          r1|j        j        rdnd}d	|d| 	                    |j        |          S | 	                    |j        |          d|d| 	                    |j        |          S )Nc              3  $   K   | ]}|j         V  d S r   r   )r   r   s     rl   r   z.JuliaCodePrinter._print_Pow.<locals>.<genexpr>   s$      >>qq{>>>>>>rm   ^z.^g      ?zsqrt(%s)g      r   r   z1 z sqrt(r   r   r   )
r   r   r   r
   r,   r   r   r   r   r   )rh   r   	powsymbolPRECsyms        rl   
_print_PowzJuliaCodePrinter._print_Pow   sM   >>DI>>>>>HCCD	$#&& 	7DI 6 666 	NDHd++ G!Y0:ccd*-##t{{49/E/E/E/EFFDHb)) N!Y0:ccd%(SS$*;*;DIt*L*L*LMM!..ty$????,,TXt<<<> 	>rm   c                    t          |          }|                     |j        |          d|                     |j        |          S )Nz ^ )r   r   r   r,   rh   r   r   s      rl   _print_MatPowzJuliaCodePrinter._print_MatPow   sL    $ --di>>>>++DHd;;;= 	=rm   c                d    | j         d         rdS t                                          |          S )Nr\   pi	_settingsr_   _print_NumberSymbolrh   r   rk   s     rl   	_print_PizJuliaCodePrinter._print_Pi   s/    >(# 	5477..t444rm   c                    dS )NrN   rp   rh   r   s     rl   _print_ImaginaryUnitz%JuliaCodePrinter._print_ImaginaryUnit   s    trm   c                d    | j         d         rdS t                                          |          S )Nr\   r   r   r   s     rl   _print_Exp1zJuliaCodePrinter._print_Exp1   s/    >(# 	5377..t444rm   c                d    | j         d         rdS t                                          |          S )Nr\   
eulergammar   r   s     rl   _print_EulerGammaz"JuliaCodePrinter._print_EulerGamma   s/    >(# 	5<77..t444rm   c                d    | j         d         rdS t                                          |          S )Nr\   catalanr   r   s     rl   _print_CatalanzJuliaCodePrinter._print_Catalan   s/    >(# 	5977..t444rm   c                d    | j         d         rdS t                                          |          S )Nr\   goldenr   r   s     rl   _print_GoldenRatioz#JuliaCodePrinter._print_GoldenRatio   s/    >(# 	5877..t444rm   c                   ddl m} ddlm} ddlm} |j        }|j        }| j        d         st          |j        |          rmg }g }|j
        D ]9\  }	}
|                     |||	                     |                    |
           : |t          ||           }|                     |          S | j        d         r@|                    |          s|                    |          r|                     ||          S |                     |          }|                     |          }|                     |d|          S )Nr   )
Assignment)	Piecewise)IndexedBaser\   r[   r   )sympy.codegen.astr  $sympy.functions.elementary.piecewiser  sympy.tensor.indexedr	  r   r   r   r   r   r   rb   r   has_doprint_loopsru   )rh   r   r  r  r	  r   r   expressions
conditionsr   r   tempr   r   s                 rl   _print_Assignmentz"JuliaCodePrinter._print_Assignment  sz   000000BBBBBB444444hh~h' 		%Jtx,K,K 		% KJ( % %A""::c1#5#5666!!!$$$$9c+z::;D;;t$$$>*% 	I377;+?+? 	I$$	I &&sC000{{3''H{{3''H&&HHHhh'GHHHrm   c                    dS )NInfrp   r   s     rl   _print_Infinityz JuliaCodePrinter._print_Infinity#      urm   c                    dS )Nz-Infrp   r   s     rl   _print_NegativeInfinityz(JuliaCodePrinter._print_NegativeInfinity'      vrm   c                    dS )NNaNrp   r   s     rl   
_print_NaNzJuliaCodePrinter._print_NaN+  r  rm   c                R     dd                      fd|D                       z   dz   S )NzAny[, c              3  B   K   | ]}                     |          V  d S r   r   r   r   rh   s     rl   r   z/JuliaCodePrinter._print_list.<locals>.<genexpr>0  s-      !?!?Q$++a..!?!?!?!?!?!?rm   ])joinr   s   ` rl   _print_listzJuliaCodePrinter._print_list/  s4    		!?!?!?!?$!?!?!????#EErm   c                    t          |          dk    rd|                     |d                   z  S d|                     |d          z  S )Nr   z(%s,)r   r   r  )r   r   	stringifyr   s     rl   _print_tuplezJuliaCodePrinter._print_tuple3  sE    t99>>T[[a1111DNN46666rm   c                    dS )Ntruerp   r   s     rl   _print_BooleanTruez#JuliaCodePrinter._print_BooleanTrue;  r  rm   c                    dS )Nfalserp   r   s     rl   _print_BooleanFalsez$JuliaCodePrinter._print_BooleanFalse?  s    wrm   c                D    t          |                                          S r   )strr   r   s     rl   _print_boolzJuliaCodePrinter._print_boolC  s    4yy   rm   c                p    t           j        |j        v rd|j        d|j        dS |j        |j        fdk    rd|d         z  S |j        dk    rd|                     ddd	
          z  S |j        dk    r$dd                     fd|D                       z  S d|                     dddd	          z  S )Nzzeros(r  r   )r   r   z[%s])r   r   r   r   r   )rowstartrowendcolsepc                :    g | ]}                     |          S rp   r   r!  s     rl   r   z6JuliaCodePrinter._print_MatrixBase.<locals>.<listcomp>U  s#    &A&A&A!t{{1~~&A&A&Arm   z;
)r2  r3  rowsepr4  )r   Zeror   r   r   tabler#  )rh   As   ` rl   _print_MatrixBasez"JuliaCodePrinter._print_MatrixBaseK  s    6QW&'fffafff55faf''AdG##Vq[[AGGD2bGMMMMVq[[DII&A&A&A&Aq&A&A&ABBBBr"',S   : : : 	:rm   c                ^   ddl m} |                                } |d |D                       } |d |D                       } |d |D                       }d|                     |          d|                     |          d|                     |          d|j        d|j        dS )	Nr   )Matrixc                $    g | ]}|d          dz   S )r   r   rp   r   ks     rl   r   z;JuliaCodePrinter._print_SparseRepMatrix.<locals>.<listcomp>^       (((AaD1H(((rm   c                $    g | ]}|d          d z   S )r   rp   r>  s     rl   r   z;JuliaCodePrinter._print_SparseRepMatrix.<locals>.<listcomp>_  r@  rm   c                    g | ]
}|d          S )   rp   r>  s     rl   r   z;JuliaCodePrinter._print_SparseRepMatrix.<locals>.<listcomp>`  s    &&&qad&&&rm   zsparse(r  r   )sympy.matricesr<  col_listr   r   r   )rh   r9  r<  LIJAIJs          rl   _print_SparseRepMatrixz'JuliaCodePrinter._print_SparseRepMatrixZ  s    ))))))JJLLF((a((())F((a((())f&&A&&&''/3{{1~~~~t{{1~~~~,0KK,<,<,<,<afffafffN 	Nrm   c                    |                      |j        t          d         d          d|j        dz   d|j        dz   dz   S )NAtomT)strict[r   ,r"  )r   parentr   r   r   r   s     rl   _print_MatrixElementz%JuliaCodePrinter._print_MatrixElemente  sJ      j.@ NNN6A:::tvzzz23 	3rm   c                      fd}                      |j                  dz    ||j        |j        j        d                   z   dz    ||j        |j        j        d                   z   dz   S )Nc                <   | d         dz   }| d         }| d         }                     |          }||k    rdn                     |          }|dk    r|dk    r||k    rdS ||k    r|S |dz   |z   S d                    |                     |          |f          S )Nr   r   rC  r   r   )r   r#  )r   limlhsteplstrhstrrh   s          rl   strslicez5JuliaCodePrinter._print_MatrixSlice.<locals>.strslicek  s    !qA!AQ4D;;q>>DHH55$++a..Dqyy66a3hh366K#:,,xxt{{4'8'8$ ?@@@rm   rN  r   rO  r   r"  )r   rP  rowslicer   colslice)rh   r   rZ  s   `  rl   _print_MatrixSlicez#JuliaCodePrinter._print_MatrixSlicej  s    	A 	A 	A 	A 	A DK((3.(9!(<==>@CD(9!(<==>@CD 	Erm   c                      fd|j         D             }                     |j        j                  dd                    |          dS )Nc                :    g | ]}                     |          S rp   r   )r   r   rh   s     rl   r   z3JuliaCodePrinter._print_Indexed.<locals>.<listcomp>  s#    777AQ777rm   rN  rO  r"  )r   r   r   r   r#  )rh   r   indss   `  rl   _print_IndexedzJuliaCodePrinter._print_Indexed  sM    7777777;;ty7777$HHrm   c                H    d|                      |j        d                   z  S )Nzeye(%s)r   )r   r   r   s     rl   _print_Identityz JuliaCodePrinter._print_Identity  s    4;;tz!}5555rm   c                T     d                      fdj        D                       S )Nz .* c                V    g | ]%}                     |t                              &S rp   r   r   r   argr   rh   s     rl   r   z;JuliaCodePrinter._print_HadamardProduct.<locals>.<listcomp>  sA     0 0 0! !--c:d3C3CDD 0 0 0rm   )r#  r   r   s   ``rl   _print_HadamardProductz'JuliaCodePrinter._print_HadamardProduct  sG    {{ 0 0 0 0 0%)Y0 0 0 1 1 	1rm   c                    t          |          }d                    |                     |j        |          |                     |j        |          g          S )Nz.**)r   r#  r   r   r,   r   s      rl   _print_HadamardPowerz%JuliaCodePrinter._print_HadamardPower  sT    $zzdi..dh--   	rm   c                b    |j         dk    rt          |j                  S |j        d|j         S )Nr   z // )r   r/  rq   r   s     rl   _print_Rationalz JuliaCodePrinter._print_Rational  s0    6Q;;tv;;!VVVTVV,,rm   c                    ddl m}m} |j        } |t          j        d|z  z             ||j        t          j        z   |          z  }|                     |          S )Nr   )r.   r<   rC  )	sympy.functionsr.   r<   argumentr   Pir   Halfr   )rh   r   r.   r<   r   expr2s         rl   	_print_jnzJuliaCodePrinter._print_jn  f    11111111MQT1Q3Z  af)<a!@!@@{{5!!!rm   c                    ddl m}m} |j        } |t          j        d|z  z             ||j        t          j        z   |          z  }|                     |          S )Nr   )r.   r=   rC  )	ro  r.   r=   rp  r   rq  r   rr  r   )rh   r   r.   r=   r   rs  s         rl   	_print_ynzJuliaCodePrinter._print_yn  ru  rm   c                    d                     |                     |j        d         t          j        z                      S )Nzsinc({})r   )rx   r   r   r   rq  r   s     rl   _print_sinczJuliaCodePrinter._print_sinc  s/      TYq\AD-@!A!ABBBrm   c                r    |j         d         j        dk    rt          d          g } j        d         rc fd|j         d d         D             }d                     |j         d         j                  z  }d                    |          |z   }d|z   d	z   S t          |j                   D ]\  }\  }}|d
k    r,|                    d                     |          z             nb|t          |j                   dz
  k    r|dk    r|                    d           n+|                    d                     |          z                                  |          }	|                    |	           |t          |j                   dz
  k    r|                    d           d                    |          S )Nr   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                    g | ]A\  }}d                                          |                              |                    BS )z({}) ? ({}) :)rx   r   )r   r   r   rh   s      rl   r   z5JuliaCodePrinter._print_Piecewise.<locals>.<listcomp>  sV     3 3 31a '--AA8 8 3 3 3rm   z (%s)
(r   r   zif (%s)r   elsezelseif (%s)r   )
r   cond
ValueErrorr   r   r   r#  	enumerater   r   )
rh   r   r   ecpairselastpwr   r   r   code0s
   `         rl   _print_Piecewisez!JuliaCodePrinter._print_Piecewise  s   9R=%%  / 0 0 0
 >(# 	$3 3 3 3#'9SbS>3 3 3G dkk$)B-*<===E7##e+B 8c>!&ty11 
( 
(	6Aq66LLT[[^^!;<<<<#di..1,,,dLL((((LLQ!?@@@AU###DI***LL'''99U###rm   c                N                                     \  }}d}|j        rZ|                                \  }}|j        r|j        rt          | |          d}n!|j        r|j        rt          | |          d}|d                     fdj        D                       z   S )Nr   r   z * c              3  ^   K   | ]'}                     |t                              V  (d S r   rf  rg  s     rl   r   z1JuliaCodePrinter._print_MatMul.<locals>.<genexpr>  s;      KK#TsJt$4$455KKKKKKrm   )as_coeff_mmulr   as_real_imagis_zeror   r	   r#  r   )rh   r   r   mr)   rO   rN   s   ``     rl   _print_MatMulzJuliaCodePrinter._print_MatMul  s    !!##1; 	^^%%FBz bn "A2q))  "A2q))ejjKKKKKKKK
 
 
 	
rm   c                  
 t          |t                    r=|                     |                    d                    }d                    |          S d}dd
d |D             }fd|D             }
fd|D             }g }d	}t          |          D ]Q\  }}	|	d
v r|                    |	           |||         z  }|                    ||z  |	           |||         z  }R|S )z0Accepts a string of code or a list of code linesTr   z    )z
^function z^if ^elseif ^else$z^for )z^end$r  r  c                8    g | ]}|                     d           S )z 	)lstrip)r   lines     rl   r   z0JuliaCodePrinter.indent_code.<locals>.<listcomp>  s$    666U##666rm   c                b    g | ]*t          t          fd D                                 +S )c              3  8   K   | ]}t          |          V  d S r   r   r   rO   r  s     rl   r   z:JuliaCodePrinter.indent_code.<locals>.<listcomp>.<genexpr>  -      BB"VB--BBBBBBrm   intany)r   r  	inc_regexs    @rl   r   z0JuliaCodePrinter.indent_code.<locals>.<listcomp>  O     ( ( ( BBBB	BBBBBCC ( ( (rm   c                b    g | ]*t          t          fd D                                 +S )c              3  8   K   | ]}t          |          V  d S r   r   r  s     rl   r   z:JuliaCodePrinter.indent_code.<locals>.<listcomp>.<genexpr>  r  rm   r  )r   r  	dec_regexs    @rl   r   z0JuliaCodePrinter.indent_code.<locals>.<listcomp>  r  rm   r   )r   r|  )r   r/  r   
splitlinesr#  r  r   )rh   code
code_linestabincreasedecreaseprettylevelnr  r  r  s             @@rl   r   zJuliaCodePrinter.indent_code  sD    dC   	'))$//$*?*?@@J77:&&&I	3	 76666( ( ( (!%( ( (( ( ( (!%( ( (   	! 	!GAtz!!d###Xa[ EMMCIItt4555Xa[ EErm   )7__name__
__module____qualname____doc__printmethodlanguage
_operatorsra   r   r]   __annotations__r`   rr   ru   rz   r~   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r$  r'  _print_Tupler*  r-  r0  r:  rJ  rQ  r]  ra  rc  ri  rk  rm  rt  rw  ry  r  r  r   __classcell__)rk   s   @rl   rQ   rQ   0   s}          KH  J )-[-J ) )	O O ) )     !# / / / / / /  ! ! !# # #3 3 3' ' 'B B B	' 	' 	'HZ HZ HZT9 9 9> > >(= = =5 5 5 5 5  5 5 5 5 55 5 5 5 55 5 5 5 55 5 5 5 5I I I:      F F F7 7 7
  L    ! ! !: : :N N N3 3 3
E E E*I I I6 6 61 1 1  - - -" " "" " "C C C"$ "$ "$H
 
 
$      rm   rQ   Nc                H    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])'
    )rQ   doprint)r   	assign_tori   s      rl   
julia_coder    s#    L H%%--dI>>>rm   c                :    t          t          | fi |           dS )z~Prints the Julia representation of the given expression.

    See `julia_code` for the meaning of the optional arguments.
    N)printr  )r   ri   s     rl   print_julia_coder    s(    
 
*T
&
&X
&
&'''''rm   r   )r  
__future__r   typingr   
sympy.corer   r   r   r   sympy.core.mulr	   sympy.core.numbersr
   sympy.printing.codeprinterr   sympy.printing.precedencer   r   rO   r   rc   rf   rQ   r  r  rp   rm   rl   <module>r     sR  	 	 # " " " " "       , , , , , , , , , , , , & & & & & & + + + + + + 2 2 2 2 2 2 < < < < < < < <      
( 
( 
( 

 K K K K K{ K K K\F? F? F? F?R( ( ( ( (rm   