wg[dZddlmZddlmZddlmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZdd lmZgd Zd d d dddddZGddeZddZdZy)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)3sincostancotseccscasinacosatanacotasecacscsinhcoshtanhcothsechcschasinhacoshatanhacothasechacschsincatan2signfloorlogexpcbrtsqrterferfcerfi factorialgammadigammatrigamma polygammabetaairyai airyaiprimeairybi airybiprimebesseljbesselybesselibesselkerfinverfcinvabsceilconjhankelh1hankelh2imagreal)Absceiling conjugatehankel1hankel2imrec eZdZUdZdZdZddddZeejfidid d d Z d e d <iffd Z dZ dZ dZdZdZdZdZdZdZdZdZfdZdZfdZfdZfdZfdZdZd Zd!Zd"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.d0Z/d1Z0d2Z1d3Z2d4Z3d5Z4d6Z5xZ6S)7JuliaCodePrinterzD A printer to convert expressions to strings of Julia code. _juliaJuliaz&&z||!)andornotT) precisionuser_functionscontractinlinezdict[str, Any]_default_settingsct||tttt|_|j j tt|jdi}|j j |y)Nr[) super__init__dictzipknown_fcns_src1known_functionsupdateknown_fcns_src2get)selfsettings userfuncs __class__s Y/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/printing/julia.pyrazJuliaCodePrinter.__init__Gsb "#C$IJ ##D$9:LL!126  ##I.c |dzS)N)rips rm_rate_index_positionz%JuliaCodePrinter._rate_index_positionOs s rnc d|zS)Nz%srq)ri codestrings rm_get_statementzJuliaCodePrinter._get_statementSs j  rnc$dj|S)Nz# {}format)ritexts rm _get_commentzJuliaCodePrinter._get_commentWs}}T""rnc&dj||S)Nz const {} = {}rx)rinamevalues rm_declare_number_constz&JuliaCodePrinter._declare_number_const[s%%dE22rnc$|j|SN) indent_code)riliness rm _format_codezJuliaCodePrinter._format_code_s&&rncJ|j\}fdt|DS)Nc3FK|]}tD]}||f ywr)range).0jirowss rm z.fs%A1U4[AAAAs!)shaper)rimatcolsrs @rm_traverse_matrix_indicesz)JuliaCodePrinter._traverse_matrix_indicescsYY dAd AArnc g}g}|D]n}t|j|j|jdz|jdzg\}}}|j d|d|d||j dp||fS)Nzfor  = :end)map_printlabellowerupperappend)riindices open_lines close_linesrvarstartstops rm_get_loop_opening_endingz)JuliaCodePrinter._get_loop_opening_endingis   &A"4;;WWaggk177Q;7 9 C   #udC D   u %  & ;&&rnc|jrO|jrC|jdjr&d|j t j |zzSt|}|j\}}|dkrt| |}d}nd}g}g}g}|jdvr|j} ntj|} | D]o} | jr| jr| jj r| jj"r| jdk7r3|j%t'| j(| j dt+| j,dj,d k7r+t/| j(tr|j%| |j%t'| j(| j  | j rG| t j0ur5| j2d k(r&|j%t5| j6_|j%| r|xst j8g}|D cgc]} |j;| |} } |D cgc]} |j;| |} } |D]N} | j(|vsd | |j=| j(z| |j=| j(<Pd }|s |||| zSt+|d k(r*|djrd nd }|||| zd|d| dSt?d|Drd nd }|||| zd|d||| dScc} wcc} w)Nrz%sim-)oldnoneF)evaluater(%s)c|d}tdt|D]%}||dz jrdnd}|d|d||}'|S)Nrr*z.* )rlen is_number)aa_strrrmulsyms rmmultjoinz-JuliaCodePrinter._print_Mul..multjoinsSaA1c!f% 7 !!A# 0 0d"#VU1X6 7Hrn/./rc34K|]}|jywrr)rbis rmrz.JuliaCodePrinter._print_Mul..s9 9z ()) r is_imaginary as_coeff_Mul is_integerrr ImaginaryUnitr r orderas_ordered_factorsr make_argsis_commutativeis_Powr- is_Rational is_negativerrbaserargs isinstanceInfinityrrrqOne parenthesizeindexall)riexprpreccer*rb pow_parenritemxrb_strrdivsyms rm _print_MulzJuliaCodePrinter._print_Mulus NNt00!!#A&11DKK(8(=>> >$  "1 q5r1%DDD   ::_ ,**,D==&D D## 8L8L,,88r>HHSTXXIFG499Q<,,-2z$))S7Q!((.HHSTXXI67!!d!**&<1 $&&)*! $ L!%%567""1d+77567""1d+77 ODyyA~,2U177499;M5N,Naggdii() O  (1e,, , Vq[aDNNSF!%hq%&8!8&%(K K9q99StF#'(1e*<#.s>qq{{>r^z.^g?zsqrt(%s)grrz1 z sqrt(rrr) rrr r r-rrrrr)rir powsymbolPRECsyms rm _print_PowzJuliaCodePrinter._print_Pows>DII>>CD $ # & DII 66 6   DHHd+!YY00cd*-t{{499/EFFDHHb)!YY00cd%($*;*;DIIt*LMM!..tyy$?,,TXXt<> >rnct|}|j|j|d|j|j|S)Nz ^ )r rrr-rirrs rm _print_MatPowzJuliaCodePrinter._print_MatPows>$ --dii>++DHHd;= =rncB|jdryt| |S)Nr]pi _settingsr`_print_NumberSymbolrirrls rm _print_PizJuliaCodePrinter._print_Pis" >>( #7.t4 4rncy)NrOrqrirs rm_print_ImaginaryUnitz%JuliaCodePrinter._print_ImaginaryUnitsrncB|jdryt| |S)Nr]rrrs rm _print_Exp1zJuliaCodePrinter._print_Exp1s" >>( #7.t4 4rncB|jdryt| |S)Nr] eulergammarrs rm_print_EulerGammaz"JuliaCodePrinter._print_EulerGammas" >>( #7.t4 4rncB|jdryt| |S)Nr]catalanrrs rm_print_CatalanzJuliaCodePrinter._print_Catalans" >>( #7.t4 4rncB|jdryt| |S)Nr]goldenrrs rm_print_GoldenRatioz#JuliaCodePrinter._print_GoldenRatios" >>( #7.t4 4rncXddlm}ddlm}ddlm}|j }|j}|jdswt|j|rag}g}|jD].\} } |j||| |j| 0|t||} |j| S|jdr4|j|s|j|r|j||S|j|} |j|} |j!| d| S)Nr) Assignment) Piecewise) IndexedBaser]r\r)sympy.codegen.astr$sympy.functions.elementary.piecewisersympy.tensor.indexedrrrrrrrrcrhas_doprint_loopsrv)rirrrrrr expressions conditionsrrtemprrs rm_print_Assignmentz"JuliaCodePrinter._print_Assignments0B4hhhh~~h'Jtxx,KKJ(( %A"":c1#56!!!$ %c+z:;D;;t$ $ >>* %377;+? $&&sC0 0{{3'H{{3'H&&Hh'GH Hrncy)NInfrqrs rm_print_Infinityz JuliaCodePrinter._print_Infinity#rncy)Nz-Infrqrs rm_print_NegativeInfinityz(JuliaCodePrinter._print_NegativeInfinity'rncy)NNaNrqrs rm _print_NaNzJuliaCodePrinter._print_NaN+rrncDddjfd|DzdzS)NzAny[, c3@K|]}j|ywr)r)rrris rmrz/JuliaCodePrinter._print_list..0s!?Q$++a.!?s])joinrs` rm _print_listzJuliaCodePrinter._print_list/s" !?$!???#EErncvt|dk(rd|j|dzSd|j|dzS)Nrz(%s,)rrr)rr stringifyrs rm _print_tuplezJuliaCodePrinter._print_tuple3s; t9>T[[a11 1DNN466 6rncy)Ntruerqrs rm_print_BooleanTruez#JuliaCodePrinter._print_BooleanTrue;rrncy)Nfalserqrs rm_print_BooleanFalsez$JuliaCodePrinter._print_BooleanFalse?srnc4t|jSr)strrrs rm _print_boolzJuliaCodePrinter._print_boolCs4y  rnc tj|jvrd|jd|jdS|j|jfdk(rd|dzS|jdk(rd|j |ddd zS|jdk(r1ddj |Dcgc]}|j|c}zSd|j |ddd d zScc}w) Nzzeros(rr)rrz[%s])rrrrr)rowstartrowendcolsepz; )r,r-rowsepr.)rZerorrrtablerr)riArs rm_print_MatrixBasez"JuliaCodePrinter._print_MatrixBaseKs 66QWW &'ffaff5 5ffaff  'AdG# # VVq[AGGD2bGMM M VVq[DIIq&A!t{{1~&ABB Br"',S :: :'Bs#C c ddlm}|j}||Dcgc] }|ddz c}}||Dcgc] }|ddz c}}||Dcgc]}|d c}}d|j|d|j|d|j|d|jd|j d Scc}wcc}wcc}w)Nr)Matrixrzsparse(rr)sympy.matricesr5col_listrrr)rir2r5LkIJAIJs rm_print_SparseRepMatrixz'JuliaCodePrinter._print_SparseRepMatrixZs) JJL a(AaD1H( ) a(AaD1H( )A&qad&'/3{{1~t{{1~,0KK,.strsliceks!qA!AQ4D;;q>DH5$++a.Dqy6a3h6K#:,,xxt{{4'8$ ?@@rnrBrrCrr)rrDrowslicercolslice)rirrNs` rm_print_MatrixSlicez#JuliaCodePrinter._print_MatrixSlicejs| A DKK(3. (9(9!(<=>@CD (9(9!(<=>@CD Ernc|jDcgc]}|j|}}|j|jjddj |dScc}w)NrBrCr)rrrrr)rirrindss rm_print_IndexedzJuliaCodePrinter._print_IndexedsJ)-7AQ77;;tyy7$HH8sA#c8|j|jSr)rrrs rm _print_IdxzJuliaCodePrinter._print_Idxs{{4::&&rncDd|j|jdzS)Nzeye(%s)r)rrrs rm_print_Identityz JuliaCodePrinter._print_Identitys4;;tzz!}555rnc dj|jDcgc]}|j|t|c}Scc}w)Nz .* )rrrr )rirargs rm_print_HadamardProductz'JuliaCodePrinter._print_HadamardProductsD{{%)YY0!!--c:d3CD01 10s"Act|}dj|j|j||j|j|gS)Nz.**)r rrrr-rs rm_print_HadamardPowerz%JuliaCodePrinter._print_HadamardPowersJ$zz   dii .   dhh - rnc|jdk(rt|jS|jd|jS)Nrz // )rr)rrrs rm_print_Rationalz JuliaCodePrinter._print_Rationals. 66Q;tvv; !VVTVV,,rncddlm}m}|j}|tj d|zz ||j tjz|z}|j|S)Nr)r/r=r6) sympy.functionsr/r=argumentrPirHalfr)rirr/r=rexpr2s rm _print_jnzJuliaCodePrinter._print_jnL1 MMQTT1Q3Z aff)r6) rar/r>rbrrcrrdr)rirr/r>rres rm _print_ynzJuliaCodePrinter._print_ynrgrnc |jdjdk7r tdg}|jdr|jddDcgc]5\}}dj |j ||j |7}}}d|j |jdj z}dj||z}d|zd zSt|jD]\}\}}|d k(r$|jd |j |znU|t|jd z k(r|dk(r|jd n#|jd|j |z|j |} |j| |t|jd z k(s|jddj|Scc}}w)NrTzAll 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]z ({}) ? ({}) :z (%s) (rrzif (%s)relsez elseif (%s)r) rcond ValueErrorrryrrr enumeraterr) rirrrrecpairselastpwrcode0s rm_print_Piecewisez!JuliaCodePrinter._print_Piecewises 99R=   %/0 0  >>( # $(99Sb>31a'-- A A83G3dkk$))B-*<*<==E7#e+B8c> !&tyy1 ( 6Aq6LLT[[^!;<#dii.1,,dLL(LLQ!?@ A U#DII**LL' (99U# #)3s :G c\j\}}d}|jrb|j\}}|jr|jrt | |d}n'|jr|jrt | |d}|dj fdjDzS)Nrrz * c3TK|]}j|t!ywr)rr )rrZrris rmrz1JuliaCodePrinter._print_MatMul..s# K#T  sJt$4 5 Ks%() as_coeff_mmulr as_real_imagis_zerorr rr)rirrmr*rPrOs`` rm _print_MatMulzJuliaCodePrinter._print_MatMuls!!#1 ;;^^%FBzzbnn"A2q)"A2q)ejj K K   rnc Ft|tr1|j|jd}dj |Sd}d}d}|Dcgc]}|j d}}|Dcgc]t tfd|D!}}|Dcgc]t tfd|D!}}g} d } t|D]C\} d vr| j| || z} | j|| z| || z } E| Scc}wcc}wcc}w) z0Accepts a string of code or a list of code linesTrz )z ^function z^if ^elseif ^else$z^for )z^end$r~rz c36K|]}t|ywrrrrPlines rmrz/JuliaCodePrinter.indent_code..B"VB-Bc36K|]}t|ywrrrs rmrz/JuliaCodePrinter.indent_code..rrr)rrk) rr)r splitlinesrlstripintanyrpr) ricode code_linestab inc_regex dec_regexrincreasedecreaseprettylevelns ` rmrzJuliaCodePrinter.indent_codesC dC ))$//$*?@J77:& &I 3 156U#66"&(B BBC(("&(B BBC((  !GAtz! d# Xa[ E MMCIt4 5 Xa[ E  ! !7((s D,$D$D)7__name__ __module__ __qualname____doc__ printmethodlanguage _operatorsrbr r^__annotations__rarsrvr{rrrrrrrrrrrrrrrrrrrr! _print_Tupler$r'r*r3r>rErQrTrVrXr[r]r_rfrirur|r __classcell__)rls@rmrRrR0sAKHJ )-[-J-J) O)~!#/!#3'B 'HZT9 >(= 55555I:F7  L! :N3 E*I '61- """$H $rnrRNc 8t|j||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])' )rRdoprint)r assign_torjs rm julia_codersL H % - -dI >>rnc .tt|fi|y)z~Prints the Julia representation of the given expression. See `julia_code` for the meaning of the optional arguments. N)printr)rrjs rmprint_julia_coders  *T &X &'rnr)r __future__rtypingr sympy.corerrrrsympy.core.mulr sympy.core.numbersr sympy.printing.codeprinterr sympy.printing.precedencer r rPrrdrgrRrrrqrnrmrsg #,,&+2< (   M{M`F?R(rn