B }[X2@sdZddlmZmZddlmZmZmZmZddl m Z m Z ddl m Z ddlmZmZddlmZmZddlmZd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:g2Zd;dd?d@dAdBZGdCdDdDeZdJdFdGZdHdIZdES)Ka 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. )print_functiondivision)MulPowSRational) string_typesrange) _keep_coeff) CodePrinter Assignment) precedence PRECEDENCE)searchZsinZcosZtanZcotZsecZcscZasinZacosZatanZacotZasecZacscZsinhZcoshZtanhZcothZsechZcschZasinhZacoshZatanhZacothZasechZ acschsincZatan2signZfloorlogexpZcbrtsqrtZerfZerfcZerfiZ factorialZgammaZdigammaZtrigammaZ polygammaZbetaZairyaiZ airyaiprimeZairybiZ airybiprimebesseljbesselyZbesseliZbesselkZerfinvZerfcinvabsZceilZconjZhankelh1Zhankelh2imagreal)ZAbsZceiling conjugateZhankel1Zhankel2imrec seZdZdZdZdZddddZdd d id d d d d Ziffdd ZddZ ddZ ddZ ddZ ddZ ddZddZddZd d!Zd"d#Zfd$d%Zd&d'Zfd(d)Zfd*d+Zfd,d-Zfd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;ZeZdd?Z!d@dAZ"dBdCZ#dDdEZ$e#Z%Z&Z'Z(Z)e$Z*Z+dFdGZ,dHdIZ-dJdKZ.dLdMZ/dNdOZ0dPdQZ1dRdSZ2dTdUZ3dVdWZ4Z5S)XJuliaCodePrinterzD A printer to convert expressions to strings of Julia code. Z_juliaZJuliaz&&z||!)andornotNautoTF)orderZ full_precZ precisionuser_functionsZhumanZallow_unknown_functionscontractinlinecsLtt||tttt|_|jtt| di}|j|dS)Nr$) superr__init__dictzipknown_fcns_src1Zknown_functionsupdateknown_fcns_src2get)selfsettingsZ userfuncs) __class__3lib/python3.7/site-packages/sympy/printing/julia.pyr(Is  zJuliaCodePrinter.__init__cCs|dS)Nr2)r/pr2r2r3_rate_index_positionQsz%JuliaCodePrinter._rate_index_positioncCsd|S)Nz%sr2)r/Z codestringr2r2r3_get_statementUszJuliaCodePrinter._get_statementcCs d|S)Nz# {0})format)r/textr2r2r3 _get_commentYszJuliaCodePrinter._get_commentcCs d||S)Nzconst {0} = {1})r8)r/namevaluer2r2r3_declare_number_const]sz&JuliaCodePrinter._declare_number_constcCs ||S)N) indent_code)r/linesr2r2r3 _format_codeaszJuliaCodePrinter._format_codecs |j\}fddt|DS)Nc3s$|]}tD]}||fVqqdS)N)r ).0ji)rowsr2r3 hsz.)shaper )r/Zmatcolsr2)rDr3_traverse_matrix_indiceses z)JuliaCodePrinter._traverse_matrix_indicescCsbg}g}xP|D]H}t|j|j|jd|jdg\}}}|d|||f|dqW||fS)Nzfor %s = %s:%send)map_printlabellowerupperappend)r/indicesZ open_linesZ close_linesrCvarstartstopr2r2r3_get_loop_opening_endingks  z)JuliaCodePrinter._get_loop_opening_endingcs|jr0|jr0|djr0dtj |St||\}}|dkr^t| |}d}nd}g}g}g}j dkr| }n t |}x|D]} | j r&| jr&| jjr&| jjr&| jdkr|t| j| j ddnDt| jdjd krt| jt r|| |t| j| j q| jrt| tjk rt| jd krV|t| j| jd kr~|t| jq|| qW|ptjg}fd d |D} fd d |D} x:|D]2} | j|krd | || j| || j<qWdd} t|dkr|| || St|d krT|djr6dnd} || || | | dStdd |Drldnd} || || | d | || SdS)Nrz%sim-)oldZnoneF)ZevaluaterIcsg|]}|qSr2) parenthesize)rAx)precr/r2r3 sz/JuliaCodePrinter._print_Mul..csg|]}|qSr2)rZ)rAr[)r\r/r2r3r]sz(%s)cSsJ|d}x.multjoin/z./cSsg|] }|jqSr2)r`)rAZbir2r2r3r]s)r`Z is_imaginaryZ as_coeff_Mul is_integerrLrZ ImaginaryUnitr r r#Zas_ordered_factorsrZ make_argsis_commutativeZis_PowrZ is_RationalZ is_negativerPrbaser_args isinstanceZInfinityr5rqOneindexall)r/exprcerrabZ pow_parenriitemrbZb_strrdZdivsymr2)r\r/r3 _print_MulwsV         $     &zJuliaCodePrinter._print_MulcCstdd|jDrdnd}t|}|jtjkr@d||jS|jr|jtj kr||jj r`dnd}d|d||jS|jtj kr|jj rdnd}d|d | |j|Sd | |j||| |j|fS) NcSsg|] }|jqSr2)r`)rAr[r2r2r3r]sz/JuliaCodePrinter._print_Pow..^z.^zsqrt(%s)rez./1z%sz%s%s%s) rnrir rrHalfrLrhrgr`rlrZ)r/roZ powsymbolPRECZsymr2r2r3 _print_Pows zJuliaCodePrinter._print_PowcCs(t|}d||j|||j|fS)Nz%s^%s)r rZrhr)r/rorxr2r2r3 _print_MatPowszJuliaCodePrinter._print_MatPowcs"|jdrdStt||SdS)Nr&Zpi) _settingsr'r_print_NumberSymbol)r/ro)r1r2r3 _print_Pis zJuliaCodePrinter._print_PicCsdS)Nrr2)r/ror2r2r3_print_ImaginaryUnitsz%JuliaCodePrinter._print_ImaginaryUnitcs"|jdrdStt||SdS)Nr&rq)r{r'rr|)r/ro)r1r2r3 _print_Exp1s zJuliaCodePrinter._print_Exp1cs"|jdrdStt||SdS)Nr&Z eulergamma)r{r'rr|)r/ro)r1r2r3_print_EulerGammas z"JuliaCodePrinter._print_EulerGammacs"|jdrdStt||SdS)Nr&Zcatalan)r{r'rr|)r/ro)r1r2r3_print_Catalans zJuliaCodePrinter._print_Catalancs"|jdrdStt||SdS)Nr&Zgolden)r{r'rr|)r/ro)r1r2r3_print_GoldenRatios z#JuliaCodePrinter._print_GoldenRatioc Csddlm}ddlm}|j}|j}|jdst|j|rg}g}x,|jD]"\}} | t ||| | qJW|t ||} | | S|jdr| |s| |r|||S| |} | |} |d| | fSdS)Nr) Piecewise) IndexedBaser&r%z%s = %s)Z$sympy.functions.elementary.piecewiserZsympy.tensor.indexedrlhsrhsr{rjrirPr r*rLZhasZ_doprint_loopsr7) r/rorrrrZ expressionsZ conditionsrqrpZtempZlhs_codeZrhs_coder2r2r3_print_Assignments$       z"JuliaCodePrinter._print_AssignmentcCsdS)NZInfr2)r/ror2r2r3_print_Infinitysz JuliaCodePrinter._print_InfinitycCsdS)Nz-Infr2)r/ror2r2r3_print_NegativeInfinity#sz(JuliaCodePrinter._print_NegativeInfinitycCsdS)NZNaNr2)r/ror2r2r3 _print_NaN'szJuliaCodePrinter._print_NaNcs ddfdd|DdS)NzAny[z, c3s|]}|VqdS)N)rL)rAra)r/r2r3rE,sz/JuliaCodePrinter._print_list..])join)r/ror2)r/r3 _print_list+szJuliaCodePrinter._print_listcCs2t|dkrd||dSd||dSdS)NrIz(%s,)rz(%s)z, )r_rLZ stringify)r/ror2r2r3 _print_tuple/s zJuliaCodePrinter._print_tuplecCsdS)Ntruer2)r/ror2r2r3_print_BooleanTrue7sz#JuliaCodePrinter._print_BooleanTruecCsdS)NZfalser2)r/ror2r2r3_print_BooleanFalse;sz$JuliaCodePrinter._print_BooleanFalsecCs t|S)N)strrN)r/ror2r2r3 _print_bool?szJuliaCodePrinter._print_boolcs|jdks|jdkr$d|j|jfS|j|jfdkr@d|dS|jdkr`d|jdddd S|jdkrdd fd d |DSd|jddd ddS)Nrz zeros(%s, %s))rIrIz[%s])rrrIrW )rowstartrowendcolsepz, csg|]}|qSr2)rL)rAra)r/r2r3r]Qsz6JuliaCodePrinter._print_MatrixBase..z; )rrZrowsepr)rDrGtabler)r/Ar2)r/r3_print_MatrixBaseGs    z"JuliaCodePrinter._print_MatrixBasecCsrddlm}|}|dd|D}|dd|D}|dd|D}d|||||||j|jfS)Nr)MatrixcSsg|]}|ddqS)rrIr2)rAkr2r2r3r]Zsz8JuliaCodePrinter._print_SparseMatrix..cSsg|]}|ddqS)rIr2)rArr2r2r3r][scSsg|] }|dqS)r2)rArr2r2r3r]\szsparse(%s, %s, %s, %s, %s))Zsympy.matricesrZcol_listrLrDrG)r/rrLIJZAIJr2r2r3_print_SparseMatrixVs z$JuliaCodePrinter._print_SparseMatrixcCs.|j|jtdddd|jd|jdfS)NZAtomT)strictz[%s,%s]rI)rZparentrrCrB)r/ror2r2r3_print_MatrixElementosz%JuliaCodePrinter._print_MatrixElementcsLfdd}|jd||j|jjdd||j|jjddS)Ncs|dd}|d}|d}|}||kr2dn|}|dkrr|dkrX||krXdS||krd|S|d|Snd|||fSdS)NrrIrrJ:)rLr)r[ZlimlhstepZlstrZhstr)r/r2r3strsliceus  z5JuliaCodePrinter._print_MatrixSlice..strslice[r,rIr)rLrZrowslicerFZcolslice)r/rorr2)r/r3_print_MatrixSlicets z#JuliaCodePrinter._print_MatrixSlicecs0fdd|jD}d|jjd|fS)Ncsg|]}|qSr2)rL)rArC)r/r2r3r]sz3JuliaCodePrinter._print_Indexed..z%s[%s]r)rQrLrhrMr)r/roZindsr2)r/r3_print_IndexedszJuliaCodePrinter._print_IndexedcCs ||jS)N)rLrM)r/ror2r2r3 _print_IdxszJuliaCodePrinter._print_IdxcCsd||jdS)Nzeye(%s)r)rLrF)r/ror2r2r3_print_Identitysz JuliaCodePrinter._print_IdentitycCsDddlm}m}|j}|tjd|||jtj|}||S)Nr)rrr) sympy.functionsrrargumentrPir#rwrL)r/rorrr[expr2r2r2r3 _print_jns$zJuliaCodePrinter._print_jncCsDddlm}m}|j}|tjd|||jtj|}||S)Nr)rrr) rrrrrrr#rwrL)r/rorrr[rr2r2r3 _print_yns$zJuliaCodePrinter._print_ync s$|jdjdkrtdg}jdrrfdd|jddD}d|jdj}d||}d |d Sxt|jD]\}\}}|d kr|d |n:|t |jd kr|dkr|dn|d||} || |t |jd kr~|dq~Wd|SdS)NrYTzAll 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&cs(g|] \}}d||qS)z({0}) ? ({1}) :)r8rL)rArqrp)r/r2r3r]sz5JuliaCodePrinter._print_Piecewise..z (%s) ()rzif (%s)rIelsez elseif (%s)rJ) riZcond ValueErrorr{rLror enumeraterPr_) r/ror?ZecpairsZelastZpwrCrqrpZcode0r2)r/r3_print_Piecewises(      z!JuliaCodePrinter._print_Piecewisec st|tr$||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }x^t|D]R\}} | dks| d kr|| qt|||8}|d ||| f|||7}qtW|S) z0Accepts a string of code or a list of code linesTrWz )z ^function z^if z^elseif z^else$z^for )z^end$z^elseif z^else$cSsg|]}|dqS)z )lstrip)rAliner2r2r3r]sz0JuliaCodePrinter.indent_code..cs&g|]ttfddDqS)csg|]}t|qSr2)r)rAr)rr2r3r]sz;JuliaCodePrinter.indent_code...)intany)rA) inc_regex)rr3r]scs&g|]ttfddDqS)csg|]}t|qSr2)r)rAr)rr2r3r]sz;JuliaCodePrinter.indent_code...)rr)rA) dec_regex)rr3r]srrz%s%s)rjrr> splitlinesrrrP) r/codeZ code_linesZtabZincreaseZdecreaseZprettylevelnrr2)rrr3r>s*      zJuliaCodePrinter.indent_code)6__name__ __module__ __qualname____doc__Z printmethodZlanguageZ _operatorsZ_default_settingsr(r6r7r:r=r@rHrUrtryrzr}r~rrrrrrrrrrZ _print_TuplerrrrrZ _print_MatrixZ_print_DenseMatrixZ_print_MutableDenseMatrixZ_print_ImmutableMatrixZ_print_ImmutableDenseMatrixZ_print_MutableSparseMatrixZ_print_ImmutableSparseMatrixrrrrrrrrr> __classcell__r2r2)r1r3r.sl K     %rNcKst|||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, Abs >>> 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, ccode >>> 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])' )rZdoprint)roZ assign_tor0r2r2r3 julia_codesrcKstt|f|dS)z~Prints the Julia representation of the given expression. See `julia_code` for the meaning of the optional arguments. N)printr)ror0r2r2r3print_julia_codessr)N)rZ __future__rrZ sympy.corerrrrZsympy.core.compatibilityrr Zsympy.core.mulr Zsympy.printing.codeprinterr r Zsympy.printing.precedencer rrrr+r-rrrr2r2r2r3 s@        ?