O/jR HdZddlmZddlmZddlmZmZmZm Z ddl m Z ddl m Z idddd d d d d ddddfdddfdddfdddfdddfdddfdddfgd d!d dfgd"d#d$d%d&d'd(d(d)d)d*d*d+d+d,d,d-d-d.d.d/d/d0d1d2d3d4dd5Zgd6ZGd7d8e ZdrIs |C4recipct|dS)Ng?r rs rrrJs |C5rsqrtct|dS)Ngr rs rrrKs |C6rz sqrt().recipc |tddk(S)N)rrs rrrLsshq!n4rcbrtct|dS)Nrr rs rrrMs |D!4rexp2r#c|jSN is_integerrs rrrNs s~~rpowir"c|j Sr(r)rs rrrOs 3>>1rpowfrcy)NT)rs rrrPsrloglnMaxmaxMinminsincostanasinacosatanatan2sinhcoshtanhasinhacoshatanh)r>r?r@rArBr)4abstractalignofasbecomeboxbreakconstcontinuecratedoelseenumexternfalsefinalfnforifimplinletloopmacromatchmodmovemutoffsetofoverrideprivprocpubpurerefreturnSelfselfsizeofstaticstructsupertraittruetypetypeofunsafeunsizedusevirtualwherewhileyieldc VeZdZUdZdZdZeejfidide dZde d<ifd Z d Z d Z d Zd ZdZdZdZdZdZdZd+fd Zd+fd ZdZdZdZdZdZd+dZd+dZd+dZd+dZ d+dZ!d+d Z"d+d!Z#d+d"Z$d#Z%d$Z&d%Z'd&Z(d'Z)fd(Z*d)Z+d*Z,xZ-S),RustCodePrinterz>A printer to convert SymPy expressions to strings of Rust code _rust_codeRustT) precisionuser_functionscontract dereferencezdict[str, Any]_default_settingsctj||tt|_|j di}|jj |t |j dg|_t t|_y)Nr}r) r __init__dictknown_functionsgetupdateset _dereferencereserved_words)rgsettings userfuncss rrzRustCodePrinter.__init__siT8,#O4LL!126  ##I. ]B ?@!.1rc |dzS)Nr/)rgps r_rate_index_positionz$RustCodePrinter._rate_index_positions s rc d|zS)Nz%s;r/)rg codestrings r_get_statementzRustCodePrinter._get_statements z!!rc d|zS)Nz// %sr/)rgtexts r _get_commentzRustCodePrinter._get_comments ~rcd|d|dS)Nzconst z: f64 = ;r/)rgnamevalues r_declare_number_constz%RustCodePrinter._declare_number_consts (,e44rc$|j|Sr() indent_code)rgliness r _format_codezRustCodePrinter._format_codes&&rcJ|j\}fdt|DS)Nc3FK|]}tD]}||f ywr()range).0ijcolss r z;RustCodePrinter._traverse_matrix_indices..s%A1U4[AAAAs!)shaper)rgmatrowsrs @r_traverse_matrix_indicesz(RustCodePrinter._traverse_matrix_indicessYY dAd AArc g}g}d}|D]o}|j||j||j|j|j|jdzdz|jdq||fS)Nz#for %(var)s in %(start)s..%(end)s {r")varstartend})append_printlowerupper)rgindices open_lines close_lines loopstartrs r_get_loop_opening_endingz(RustCodePrinter._get_loop_opening_endings  9  $A   i{{1~QWW-{{177Q;/+11 2   s #  $;&&rct|jdkDrd|j|zdzS|jr|j|dS|j|S)Nr"()T)_type)lenargsr is_numberrgexprs r_print_caller_varz!RustCodePrinter._print_caller_varsV tyy>A T**S0 0 ^^;;t4;0 0;;t$ $rc|jjjvr6j|jj}d}d}t|tr|}n|D]\}}}||j sn||dk(r^dj |j d|t|j dkDrj|j dddnddz}|S|dk(r&d j |j d|d z}|S|d k(r&d j |j d|d z}|Sd |j|j dd z}|Syt|drBt|jtr(j|j|j S|jjjvrmj|jj\}}j|r5tfd|Dr j|j!|Syyj#|S)a< basic function for printing `Function` Function Style : 1. args[0].func(args[1:]), method with arguments 2. args[0].func(), method without arguments 3. args[1].func(), method without arguments (e.g. (e, x) => x.exp()) 4. func(args), function with arguments Nr"z%(var)s.%(method)s(%(args)s)r, )rmethodrrz%(var)s.%(method)s())rrr#z%(func)s(%(args)s))funcr_imp_c3@K|]}j|ywr() _can_print)rfrgs rrz2RustCodePrinter._print_Function..Ms0Y1C0Y)r__name__r isinstancestrrrr stringifyhasattrrrr_rewriteable_functionsrallrewrite_print_not_supported) rgr cond_funcrstylecondrettarget_f required_fss ` r_print_FunctionzRustCodePrinter._print_Functions; 99  !5!5 5,,TYY-?-?@IDE)S) )2%D$TYY'A:8#55diilC"&GJ499~XYGYtyy}d C_a<C( aZ0#55diilC"&4C aZ0#55diilC"&4C / $ $tyy$ ?2C - .T7 # 4::v(F;;ztzz49956 6 YY  4#>#> >$($?$? @R@R$S !Hkx(S0Y[0Y-Y{{4<<#9::.Z(,,T2 2rc|jjrV|jjs@t|t |j|j}|j |S|j |Sr()rr*rrnrrrrs r _print_PowzRustCodePrinter._print_PowRsZ 99  (;(;4:eDII.9D;;t$ $##D))rc4t||}|r|dzS|S)N_f64)rk _print_Floatrgrrr __class__s rrzRustCodePrinter._print_FloatXs$g"4( < Jrc4t||}|r|dzS|S)N_i32)rk_print_Integerrs rrzRustCodePrinter._print_Integer_s$g$T* < Jrcdt|jt|j}}d||fzS)Nz %d_f64/%d.0)intrq)rgrrrs r_print_RationalzRustCodePrinter._print_Rationalfs*466{CK11v%%rc|j|j}|j|j}|j}dj |||S)Nz{} {} {})rlhsrhsrel_opformat)rgrlhs_coderhs_codeops r_print_Relationalz!RustCodePrinter._print_RelationaljsD;;txx(;;txx( [[  2x88rcN|j}tj}tj}t t |j D]}||j||zz }|||z}!|j|jjd|j|dS)N[]) rrZeroOnereversedrrankrrrlabel)rgrdimselemoffsetrs r_print_IndexedzRustCodePrinter._print_Indexedpszzvv% *+ A DLLOF* *D d1g F  ;;tyy7T9JKKrc.|jjSr()rrrs r _print_IdxzRustCodePrinter._print_Idxzszzrc|jSr()rrs r _print_DummyzRustCodePrinter._print_Dummy}s yyrcy)NEr/rgrrs r _print_Exp1zRustCodePrinter._print_Exp1srcy)NPIr/rs r _print_PizRustCodePrinter._print_Pisrcy)NINFINITYr/rs r_print_InfinityzRustCodePrinter._print_Infinitysrcy)N NEG_INFINITYr/rs r_print_NegativeInfinityz'RustCodePrinter._print_NegativeInfinitysrcy)Nrmr/rs r_print_BooleanTruez"RustCodePrinter._print_BooleanTruesrcy)NrPr/rs r_print_BooleanFalsez#RustCodePrinter._print_BooleanFalsesrc4t|jSr()rrrs r _print_boolzRustCodePrinter._print_bools4y  rcy)NNANr/rs r _print_NaNzRustCodePrinter._print_NaNsrcH|jdjdk7r tdg}t|jD]\}\}}|dk(r$|j d|j |znM|t |jdz k(r|dk(r|dxxdz cc<n|dxxd|j |zz cc<|j |}|j ||j d |jd rd j|Sd j|S) 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.rz if (%s) {r"z else {z else if (%s) {rinline  ) rr ValueError enumeraterrr _settingsjoin)rgrrreccode0s r_print_Piecewisez RustCodePrinter._print_Piecewises 99R=   %/0 0 "499- IAv1Av [4;;q>9:c$))nq((Q$Yb Y& b .Q?? KKNE LL  LL   >>( #88E? "99U# #rcRddlm}|j|j|dS)Nr) PiecewiseF)deep)sympy.functionsr'rr)rgrr's r _print_ITEzRustCodePrinter._print_ITEs!-{{4<< <>??rcr|jdk(rddjfd|DzStd)Nr"z[%s]rc3@K|]}j|ywr()r)rargs rrz4RustCodePrinter._print_MatrixBase..s%@dkk!n%@rzLFull Matrix Support in Rust need Crates (https://crates.io/keywords/matrix).)rr!r)rgAs` r_print_MatrixBasez!RustCodePrinter._print_MatrixBases4 66Q;DII%@a%@@@ @kl lrc$|j|Sr()r)rgrs r_print_SparseRepMatrixz&RustCodePrinter._print_SparseRepMatrixs((--rc|jd|j|j|jjdzzdS)Nrr"r)parentrrrrs r_print_MatrixElementz$RustCodePrinter._print_MatrixElements9;;66DFF4;;+<+ !Krc4ddlm}|j}|j}|jdr4|j |s|j |r|j ||S|j|}|j|}|j|d|S)Nr) IndexedBaser~z = ) sympy.tensor.indexedr8rrr has_doprint_loopsrr)rgrr8rrrrs r_print_Assignmentz!RustCodePrinter._print_Assignments4hhhh >>* %377;+? $&&sC0 0{{3'H{{3'H&&Hh'GH Hrc lt|tr1|j|jd}dj |Sd}d}d}|Dcgc]}|j d}}|Dcgc]*}t tt|j|,}}|Dcgc]*}t tt|j|,}}g} d} t|D]C\} }|dvr| j|| || z} | j|| z|| || z } E| Scc}wcc}wcc}w) z0Accepts a string of code or a list of code linesTrz ){rz{ z( )rrz r)rr) rrr splitlinesr!lstripranymapendswith startswithrr) rgcode code_linestab inc_token dec_tokenlineincreasedecreaseprettylevelns rrzRustCodePrinter.indent_codes: dC ))$//$*?@J77:& &,  046U#66IMOSS :;<OO!%(S)<=>((  !GAtz! d# Xa[ E MMCIt4 5 Xa[ E  ! 7O(s D'*/D,/D1)F).r __module__ __qualname____doc__ printmethodlanguagerr rr__annotations__rrrrrrrrrrrrrrrrrrrr r rrrrrr%r*r/r1r4r6r<r __classcell__)rs@rrxrxsHKH(,[-J-J)u O)~!#2"5'B ' %63p* &9 L!$6@m .A IrrxNc 8t|j||S)aConverts an expr to a string of Rust 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 is helpful in case of line-wrapping, or for expressions that generate multi-line statements. precision : integer, optional The precision for numbers such as pi [default=15]. user_functions : dict, optional A dictionary where the keys are string representations of either ``FunctionClass`` or ``UndefinedFunction`` instances and the values are their desired C string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples. dereference : iterable, optional An iterable of symbols that should be dereferenced in the printed code expression. These would be values passed by address to the function. For example, if ``dereference=[a]``, the resulting code would print ``(*a)`` instead of ``a``. 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]. Examples ======== >>> from sympy import rust_code, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> rust_code((2*tau)**Rational(7, 2)) '8*1.4142135623731*tau.powf(7_f64/2.0)' >>> rust_code(sin(x), assign_to="s") 's = x.sin();' Simple 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)]. >>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs", 4), ... (lambda x: x.is_integer, "ABS", 4)], ... "func": "f" ... } >>> func = Function('func') >>> rust_code(func(Abs(x) + ceiling(x)), user_functions=custom_functions) '(fabs(x) + x.CEIL()).f()' ``Piecewise`` expressions are converted into conditionals. If an ``assign_to`` variable is provided an if statement is created, otherwise the ternary operator is used. 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 >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(rust_code(expr, tau)) tau = if (x > 0) { x + 1 } else { 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])) >>> rust_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);' Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions must be provided to ``assign_to``. Note that any expression that can be generated normally can also exist inside a Matrix: >>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(rust_code(mat, A)) A = [x.powi(2), if (x > 0) { x + 1 } else { x }, x.sin()]; )rxdoprint)r assign_tors r rust_coderZsZ 8 $ , ,T9 ==rc .tt|fi|y)z3Prints Rust representation of the given expression.N)printrZ)rrs rprint_rust_coder]is )D %H %&rr()rR __future__rtypingr sympy.corerrrrsympy.core.numbersr sympy.printing.codeprinterr rrrxrZr]r/rrrcs B#11+2$2  W 2v2 52 H2  4gq A 5vq A 6 J 4fa @ 4fa @ -vq 9 161 =  ?!2. ua ( )/20 412< 5=2> 5?2B 5C2D 5E2F 5G2H FI2J FK2L FM2N WO2V FW2X      c2X3l[k[|m>`'r