o GZh[@sdZddlmZddlmZddlmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZdd lmZgd Zd d d dddddZGdddeZdddZddZdS)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)MulPowSRational) _keep_coeff) equal_valued) CodePrinter) precedence PRECEDENCEsearch)2sincostanZcotsecZcscasinacosatanZacotZasecZacscsinhcoshtanhZcothZsechZcschasinhacoshatanhZacothZasechZacschatan2signfloorlogexpZcbrtsqrterferfcZerfi factorialgammaZdigammaZtrigammaZ polygammabetaZairyaiZ airyaiprimeZairybiZ airybiprimebesseljbesselyZbesseliZbesselkZerfinvZerfcinvabsceilZconjZhankelh1Zhankelh2imagreal)ZAbsZceiling conjugateZhankel1Zhankel2imrecseZdZUdZdZdZddddZeej fidid d d Z d e d <iffd d Z ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zd#d$Zfd%d&Zd'd(Zfd)d*Zfd+d,Zfd-d.Zfd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"e"Z#d=d>Z$d?d@Z%dAdBZ&dCdDZ'dEdFZ(dGdHZ)dIdJZ*dKdLZ+dMdNZ,dOdPZ-dQdRZ.dSdTZ/dUdVZ0dWdXZ1dYdZZ2d[d\Z3d]d^Z4d_d`Z5Z6S)aJuliaCodePrinterzD A printer to convert expressions to strings of Julia code. Z_juliaJuliaz&&z||!)andornotT) precisionuser_functionscontractinlinezdict[str, Any]_default_settingscsHt|tttt|_|jtt|di}|j|dS)Nr8) super__init__dictzipknown_fcns_src1Zknown_functionsupdateknown_fcns_src2get)selfsettingsZ userfuncs __class__C/var/www/auris/lib/python3.10/site-packages/sympy/printing/julia.pyr=Gs  zJuliaCodePrinter.__init__cCs|dS)NrH)rDprHrHrI_rate_index_positionOz%JuliaCodePrinter._rate_index_positioncCsd|S)Nz%srH)rDZ codestringrHrHrI_get_statementSrMzJuliaCodePrinter._get_statementcCs d|S)Nz# {}format)rDtextrHrHrI _get_commentW zJuliaCodePrinter._get_commentcCs d||S)Nz const {} = {}rO)rDnamevaluerHrHrI_declare_number_const[ z&JuliaCodePrinter._declare_number_constcCs ||SN) indent_code)rDlinesrHrHrI _format_code_rSzJuliaCodePrinter._format_codecs |j\}fddt|DS)Nc3s&|]}tD]}||fVqqdSrX)range).0jirowsrHrI fs$z.)shaper\)rDmatcolsrHr`rI_traverse_matrix_indicescs z)JuliaCodePrinter._traverse_matrix_indicescCs^g}g}|D]$}t|j|j|jd|jdg\}}}|d|||f|dq||fS)Nzfor %s = %s:%send)map_printlabellowerupperappend)rDindicesZ open_linesZ close_linesr_varstartstoprHrHrI_get_loop_opening_endingis  z)JuliaCodePrinter._get_loop_opening_endingcsH|jr|jr|djrdtj |St||\}}|dkr/t| |}d}nd}g}g}g}j dvrA| }nt |}|D]_} | j r| jr| jjr| jjr| jdkrk|t| j| j ddqHt| jdjd krt| jt r|| |t| j| j qH| jr| tjur| jd kr|t| jqH|| qH|ptjg}fd d |D} fd d |D} |D]} | j|vrd | || j| || j<qdd} |s|| || St|d kr|djrdnd} d|| || | | dfStdd|Drdnd} d|| || | | || fS)Nrz%sim-)oldnoneF)evaluatergcg|]}|qSrH parenthesizer]xprecrDrHrI z/JuliaCodePrinter._print_Mul..crzrHr{r}rrHrIrr(%s)cSsH|d}tdt|D]}||djrdnd}d||||f}q |S)Nrrg*z.*%s %s %s)r\len is_number)aa_strrr_ZmulsymrHrHrImultjoins z-JuliaCodePrinter._print_Mul..multjoin/./rcs|]}|jVqdSrXr)r]ZbirHrHrIrbz.JuliaCodePrinter._print_Mul..z %s %s (%s))rZ is_imaginaryZ as_coeff_Mul is_integerrjrZ ImaginaryUnitr rorderZas_ordered_factorsrZ make_argsis_commutativeZis_Powr Z is_Rational is_negativernrbaserargs isinstanceInfinityrKrqZOneindexall)rDexprcerrbZ pow_parenritemrZb_strrZdivsymrHrrI _print_MulusV              zJuliaCodePrinter._print_MulcCs,||j}||j}|j}d|||S)Nz{} {} {})rjlhsrhsZrel_oprP)rDrlhs_coderhs_codeoprHrHrI_print_Relationals  z"JuliaCodePrinter._print_RelationalcCstdd|jDr dnd}t|}t|jdr d||jS|jrTt|jdr;|jjr/dnd }d |||jfSt|jd rT|jjrGdnd }d || |j|fSd | |j||| |j|fS)NcsrrXrr}rHrHrIrbrz.JuliaCodePrinter._print_Pow..^z.^g?zsqrt(%s)grrz 1 %s sqrt(%s)rxz1 %s %sr) rrr r r rjrrrr|)rDrZ powsymbolPRECsymrHrHrI _print_Pows    zJuliaCodePrinter._print_PowcCs(t|}d||j|||j|fS)Nz%s ^ %s)r r|rr rDrrrHrHrI _print_MatPows zJuliaCodePrinter._print_MatPowc|jdrdSt|S)Nr:pi _settingsr<Z_print_NumberSymbolrDrrFrHrI _print_Pi  zJuliaCodePrinter._print_PicCdS)Nr.rHrrHrHrI_print_ImaginaryUnitz%JuliaCodePrinter._print_ImaginaryUnitcr)Nr:rrrrFrHrI _print_Exp1rzJuliaCodePrinter._print_Exp1cr)Nr:Z eulergammarrrFrHrI_print_EulerGammarz"JuliaCodePrinter._print_EulerGammacr)Nr:catalanrrrFrHrI_print_CatalanrzJuliaCodePrinter._print_Catalancr)Nr:ZgoldenrrrFrHrI_print_GoldenRatiorz#JuliaCodePrinter._print_GoldenRatiocCsddlm}ddlm}ddlm}|j}|j}|jdsHt |j|rHg}g}|j D]\} } | ||| | | q*|t ||} | | S|jdr]||sW||r]|||S| |} | |} |d| | fS)Nr) Assignment) Piecewise) IndexedBaser:r9z%s = %s)Zsympy.codegen.astrZ$sympy.functions.elementary.piecewiserZsympy.tensor.indexedrrrrrrrnr?rjhasZ_doprint_loopsrN)rDrrrrrrZ expressionsZ conditionsrrtemprrrHrHrI_print_Assignments(        z"JuliaCodePrinter._print_AssignmentcCr)NZInfrHrrHrHrI_print_Infinity#rz JuliaCodePrinter._print_InfinitycCr)Nz-InfrHrrHrHrI_print_NegativeInfinity'rz(JuliaCodePrinter._print_NegativeInfinitycCr)NNaNrHrrHrHrI _print_NaN+rzJuliaCodePrinter._print_NaNcs ddfdd|DdS)NzAny[, c3s|]}|VqdSrXrjr]rrDrHrIrb0z/JuliaCodePrinter._print_list..])joinrrHrrI _print_list/s zJuliaCodePrinter._print_listcCs.t|dkrd||dSd||dS)Nrgz(%s,)rrr)rrj stringifyrrHrHrI _print_tuple3s zJuliaCodePrinter._print_tuplecCr)NtruerHrrHrHrI_print_BooleanTrue;rz#JuliaCodePrinter._print_BooleanTruecCr)NfalserHrrHrHrI_print_BooleanFalse?rz$JuliaCodePrinter._print_BooleanFalsecCs t|SrX)strrlrrHrHrI _print_boolCrWzJuliaCodePrinter._print_boolcstj|jvrd|j|jfS|j|jfdkrd|dS|jdkr,d|jddddS|jdkr?dd fd d |DSd|jddd dd S)Nz zeros(%s, %s))rgrgz[%s])rrrgru )rowstartrowendcolseprcg|]}|qSrHrrrrHrIrUz6JuliaCodePrinter._print_MatrixBase..z; )rrZrowsepr)rZZerorcraretabler)rDArHrrI_print_MatrixBaseKs     z"JuliaCodePrinter._print_MatrixBasecCsrddlm}|}|dd|D}|dd|D}|dd|D}d|||||||j|jfS)Nr)MatrixcSsg|]}|ddqS)rrgrHr]krHrHrIr^rz;JuliaCodePrinter._print_SparseRepMatrix..cSsg|]}|ddqS)rgrHrrHrHrIr_rcSsg|]}|dqS)rHrrHrHrIr`szsparse(%s, %s, %s, %s, %s))Zsympy.matricesrZcol_listrjrare)rDrrLIJZAIJrHrHrI_print_SparseRepMatrixZs z'JuliaCodePrinter._print_SparseRepMatrixcCs.|j|jtdddd|jd|jdfS)NZAtomT)strictz[%s,%s]rg)r|parentr r_r^rrHrHrI_print_MatrixElementesz%JuliaCodePrinter._print_MatrixElementcsLfdd}|jd||j|jjdd||j|jjddS)Ncs|dd}|d}|d}|}||krdn|}|dkr8|dkr,||kr,dS||kr2|S|d|Sd|||fS)Nrrgrrh:)rjr)r~ZlimlhstepZlstrZhstrrrHrIstrsliceks   z5JuliaCodePrinter._print_MatrixSlice..strslice[r,rgr)rjrZrowslicercZcolslice)rDrrrHrrI_print_MatrixSlicejs z#JuliaCodePrinter._print_MatrixSlicecs0fdd|jD}d|jjd|fS)NcrrHr)r]r_rrHrIrrz3JuliaCodePrinter._print_Indexed..z%s[%s]r)rorjrrkr)rDrZindsrHrrI_print_IndexedszJuliaCodePrinter._print_IndexedcCsd||jdS)Nzeye(%s)r)rjrcrrHrHrI_print_Identitysz JuliaCodePrinter._print_IdentitycsdfddjDS)Nz .* csg|] }|tqSrHr|r r]argrrDrHrIrsz;JuliaCodePrinter._print_HadamardProduct..)rrrrHrrI_print_HadamardProductsz'JuliaCodePrinter._print_HadamardProductcCs*t|}d||j|||j|gS)Nz.**)r rr|rr rrHrHrI_print_HadamardPowers   z%JuliaCodePrinter._print_HadamardPowercCs$|jdkr t|jSd|j|jfS)Nrgz%s // %s)rrrKrrHrHrI_print_Rationals  z JuliaCodePrinter._print_RationalcCDddlm}m}|j}|tjd|||jtj|}||S)Nr)r!r'r) sympy.functionsr!r'argumentrPirHalfrj)rDrr!r'r~expr2rHrHrI _print_jn$ zJuliaCodePrinter._print_jncCr)Nr)r!r(r) rr!r(rrrrrrj)rDrr!r(r~rrHrHrI _print_ynrzJuliaCodePrinter._print_yncCsd||jdtjS)Nzsinc({})r)rPrjrrrrrHrHrI _print_sincszJuliaCodePrinter._print_sincc s|jdjdkr tdg}jdr9fdd|jddD}d|jdj}d||}d |d St|jD]J\}\}}|d krS|d |n|t |jd krf|dkrf|dn |d||} || |t |jd kr|dq>d|S)NrxTzAll 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 ({}) ? ({}) :)rPrj)r]rrrrHrIrs z5JuliaCodePrinter._print_Piecewise..z (%s) ()rzif (%s)rgelsez elseif (%s)rh) rZcond ValueErrorrrjrr enumeraternr) rDrrZZecpairsZelastpwr_rrZcode0rHrrI_print_Piecewises,         z!JuliaCodePrinter._print_Piecewisecs|\}}d}|jr.|\}}|jr |jr t| |d}n|jr.|jr.t| |d}|dfddjDS)Nrurtz * c3s |] }|tVqdSrXrrrrHrIrbsz1JuliaCodePrinter._print_MatMul..)Z as_coeff_mmulrZ as_real_imagis_zerorrrr)rDrrmrr/r.rHrrI _print_MatMuls      zJuliaCodePrinter._print_MatMulc st|tr||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }t|D]%\}} | d vrG|| q9|||8}|d ||| f|||7}q9|S) z0Accepts a string of code or a list of code linesTruz )z ^function z^if ^elseif ^else$z^for )z^end$rrcSsg|]}|dqS)z )lstrip)r]linerHrHrIrrz0JuliaCodePrinter.indent_code..c&g|]ttfddDqS)c3|]}t|VqdSrXr r]r/rrHrIrbr:JuliaCodePrinter.indent_code...intanyr]) inc_regexrrIrcr)c3rrXr rrrHrIrbrrrr) dec_regexrrIrrr)rurz%s%s)rrrY splitlinesrr rn) rDcodeZ code_linestabZincreaseZdecreaseprettylevelnrrH)r rrIrYs.      zJuliaCodePrinter.indent_code)7__name__ __module__ __qualname____doc__Z printmethodlanguage _operatorsr>r r;__annotations__r=rLrNrRrVr[rfrsrrrrrrrrrrrrrrrrZ _print_Tuplerrrrrrrrrrrrrrrr rrY __classcell__rHrHrFrIr00sr    J      $r0NcKst|||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])' )r0Zdoprint)rZ assign_torErHrHrI julia_codesr/cKstt|fi|dS)z~Prints the Julia representation of the given expression. See `julia_code` for the meaning of the optional arguments. N)printr/)rrErHrHrIprint_julia_codesr1rX)r* __future__rtypingrZ sympy.corerrrrZsympy.core.mulrZsympy.core.numbersr Zsympy.printing.codeprinterr Zsympy.printing.precedencer r r/rr@rBr0r/r1rHrHrHrIs2       Q