^jR PdZddlmZddlmZddlmZmZmZm 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|C44recipc"t|dS)Ng?r rs rrrJs|C55rsqrtc"t|dS)Ngr rs rrrKs|C66rz sqrt().recipc*|tddkS)N)rrs rrrLsshq!nn4rcbrtc"t|dS)Nrr rs rrrMs|D!44rexp2r#c|jSN is_integerrs rrrNss~rpowir"c|j Sr(r)rs rrrOs 3>1rpowfrcdS)NT)rs rrrPsrloglnMaxmaxMinminsincostanasinacosatanatan2sinhcoshtanhasinhacoshatanh)r>r?r@rArBr)4abstractalignofasbecomeboxbreakconstcontinuecratedoelseenumexternfalsefinalfnforifimplinletloopmacromatchmodmovemutoffsetofoverrideprivprocpubpurerefreturnSelfselfsizeofstaticstructsupertraittruetypetypeofunsafeunsizedusevirtualwherewhileyieldc ReZdZUdZdZdZeejfidide dZde d<ifd Z d Z d Z d Zd ZdZdZdZdZdZdZd,fd Zd,fd ZdZdZdZdZdZd,dZd,dZd,dZd,dZ d,d Z!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_settingscDtj||tt|_|di}|j|t |dg|_t t|_dS)Nr}r) r __init__dictknown_functionsgetupdateset _dereferencereserved_words)rgsettings userfuncss rrzRustCodePrinter.__init__sT8,,,#O44LL!1266  ##I... ]B ? ?@@!.11rc |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(,eee44rc,||Sr() indent_code)rgliness r _format_codezRustCodePrinter._format_codes&&&rcN|j\}fdt|DS)Nc3DK|]}tD]}||fV dSr()range).0ijcolss r z;RustCodePrinter._traverse_matrix_indices..s:AA1U4[[AAAAAAAAAAr)shaper)rgmatrowsrs @r_traverse_matrix_indicesz(RustCodePrinter._traverse_matrix_indicess.Y dAAAAd AAAArc g}g}d}|D]y}||||||j||jdzdz|dz||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~~QW--{{17Q;//+1+11 2 2 2   s # # # #;&&rct|jdkrd||zdzS|jr||dS||S)Nr"()T)_type)lenargsr is_numberrgexprs r_print_caller_varz!RustCodePrinter._print_caller_varse ty>>A  T***S0 0 ^ %;;t4;00 0;;t$$ $rcd|jjjvr2j|jj}d}d}t|tr|}n|D]\}}}||jrn||dkrcd|jd|t|jdkr#|jdddnddz}n{|dkr'd |jd|d z}nN|d kr'd |jd|d z}n!d ||jdd z}|SdSt|dr 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_c3BK|]}|VdSr() _can_print)rfrgs rrz2RustCodePrinter._print_Function..Ms/0Y0Y1C1C0Y0Y0Y0Y0Y0Yr)r__name__r isinstancestrrrr stringifyhasattrrrr_rewriteable_functionsrallrewrite_print_not_supported) rgr cond_funcrstylecondrettarget_f required_fss ` r_print_FunctionzRustCodePrinter._print_Functions 9 !5 5 5,TY-?@IDE)S))  )2%D$tTY'A::8#55dilCC"&GJ49~~XYGYGYty}d C C C_a<<CC aZZ0#55dilCC"&44CCaZZ0#55dilCC"&44CC / $ $ty$ ? ?22C - .T7 # # 3 4:v(F(F 3;;ztz49566 6 Y 4#> > >$($? @R$S !Hkx(( ;S0Y0Y0Y0Y[0Y0Y0Y-Y-Y ;{{4<<#9#9::: ; ; ; ;,,T22 2rc|jjrQ|jjsEt|t |j|j}||S||Sr()rr*rrnrrrrs r _print_PowzRustCodePrinter._print_PowRsd 9  %(; %4::eDI..99D;;t$$ $##D)))rFcXt|}|r|dzS|S)N_f64)rk _print_Floatrgrrr __class__s rrzRustCodePrinter._print_FloatXs1gg""4((  < JrcXt|}|r|dzS|S)N_i32)rk_print_Integerrs rrzRustCodePrinter._print_Integer_s1gg$$T**  < Jrc`t|jt|j}}d||fzS)Nz %d_f64/%d.0)intrq)rgrrrs r_print_RationalzRustCodePrinter._print_Rationalfs*46{{CKK11v%%rc||j}||j}|j}d|||S)Nz{} {} {})rlhsrhsrel_opformat)rgrlhs_coderhs_codeops r_print_Relationalz!RustCodePrinter._print_RelationaljsG;;tx((;;tx(( [  2x888rc4|j}tj}tj}t t |jD] }||j||zz }|||z}!||j j d||dS)N[]) rrZeroOnereversedrrankrrrlabel)rgrdimselemoffsetrs r_print_IndexedzRustCodePrinter._print_Indexedpszv% **++  A DLOF* *D d1g FF;;ty7777T9J9J9J9JKKrc|jjSr()rrrs r _print_IdxzRustCodePrinter._print_Idxzs zrc|jSr()rrs r _print_DummyzRustCodePrinter._print_Dummy}s yrcdS)NEr/rgrrs r _print_Exp1zRustCodePrinter._print_Exp1ssrcdS)NPIr/rs r _print_PizRustCodePrinter._print_PistrcdS)NINFINITYr/rs r_print_InfinityzRustCodePrinter._print_InfinityszrcdS)N NEG_INFINITYr/rs r_print_NegativeInfinityz'RustCodePrinter._print_NegativeInfinitys~rcdS)Nrmr/rs r_print_BooleanTruez"RustCodePrinter._print_BooleanTruesvrcdS)NrPr/rs r_print_BooleanFalsez#RustCodePrinter._print_BooleanFalseswrcDt|Sr()rrrs r _print_boolzRustCodePrinter._print_bools4yy   rcdS)NNANr/rs r _print_NaNzRustCodePrinter._print_NaNsurc|jdjdkrtdg}t|jD]\}\}}|dkr,|d||znX|t |jdz kr|dkr|dxxdz cc<n&|dxxd||zz cc<||}|||d |jd rd |Sd |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_PiecewisesI 9R=  % %/00 0 "49--  IAv1Avv [4;;q>>9::::c$)nnq(((Q$YYb Y& b .Q?? KKNNE LL    LL     >( # $88E?? "99U## #rcbddlm}|||dS)Nr) PiecewiseF)deep)sympy.functionsr&rr)rgrr&s r _print_ITEzRustCodePrinter._print_ITEs6------{{4<< <>>???rc|jdkr$ddfd|DzStd)Nr"z[%s]rc3BK|]}|VdSr()r)rargs rrz4RustCodePrinter._print_MatrixBase..s-%@%@dkk!nn%@%@%@%@%@%@rzLFull Matrix Support in Rust need Crates (https://crates.io/keywords/matrix).)rr r)rgAs` r_print_MatrixBasez!RustCodePrinter._print_MatrixBasesI 6Q;;DII%@%@%@%@a%@%@%@@@@ @kll lrc,||Sr()r)rgrs r_print_SparseRepMatrixz&RustCodePrinter._print_SparseRepMatrixs((---rc\|jd|j|j|jjdzzdS)Nrr"r)parentrrrrs r_print_MatrixElementz$RustCodePrinter._print_MatrixElements8;;;6DF4;+ !KrcLddlm}|j}|j}|jdr@||s||r|||S||}||}||d|S)Nr) IndexedBaser~z = ) sympy.tensor.indexedr7rrrhas_doprint_loopsrr)rgrr7rrrrs r_print_Assignmentz!RustCodePrinter._print_Assignments444444hh >* % I377;+?+? I $$ I&&sC00 0{{3''H{{3''H&&HHHhh'GHH Hrc t|tr=||d}d|Sd}d d d|D} fd|D} fd|D}g}d }t |D]Q\}} | d vr|| |||z}|||z| |||z }R|S) z0Accepts a string of code or a list of code linesTrz ){rz{ z( )rrc8g|]}|dS)z )lstrip)rlines r z/RustCodePrinter.indent_code..s$666U##666rc ng|]1}ttt|j2Sr/)ranymapendswith)rr@ inc_tokens rrAz/RustCodePrinter.indent_code..s5OOOSS ::;;<<OOOrc ng|]1}ttt|j2Sr/)rrCrD startswith)rr@ dec_tokens rrAz/RustCodePrinter.indent_code..sE(((S)<<==>>(((rr)rr)rrr splitlinesr rr) rgcode code_linestabincreasedecreaseprettylevelnr@rIrFs @@rrzRustCodePrinter.indent_codes3 dC  '))$//$*?*?@@J77:&& &,  66666OOOOOOO((((!%(((  ! !GAtz!! d### Xa[ E MMCIItt4 5 5 5 Xa[ EE r)F).r __module__ __qualname____doc__ printmethodlanguagerr rr__annotations__rrrrrrrrrrrrrrrrrrrr r rrrrrr$r)r.r0r3r5r;r __classcell__)rs@rrxrxsHHKH(,[-J))suu OO))!#2222"""555'''BBB ' ' ' % % %636363p*** &&&999 LLL!!!!$$$6@@@mmm ...AAA I I IrrxNc Ht|||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_coder]s#Z 8 $ $ , ,T9 = ==rc :tt|fi|dS)z3Prints Rust representation of the given expression.N)printr])rrs rprint_rust_coder`is& )D % %H % %&&&&&rr()rU __future__rtypingr sympy.corerrrrsympy.core.numbersr sympy.printing.codeprinterr rrrxr]r`r/rrrfsj  B#"""""111111111111++++++222222$2  W 2v2 52 H2  4 4gq A 5 5vq A 6 6 J 4 4fa @ 4 4fa @ - -vq 9 1 161 =  ?!2.  ua ( )/20 412< 5=2> 5?2B 5C2D 5E2F 5G2H FI2J FK2L FM2N WO2V FW2X      c222X333l[[[[[k[[[|m>m>m>m>`'''''r