o 8VaQ @s@dZddlmZmZddlmZmZmZmZddl m Z idddddd d d d d dddfddddfddddfddddfddddfddddfddddfgdd dddfgd!d"d#d$d%d&d'd'd(d(d)d)d*d*d+d+d,d,d-d-d.d.d/d0d1d2d3d4Z gd5Z Gd6d7d7e Z d=d9d:Zd;d<Zd8S)>a Rust code printer The `RustCodePrinter` converts SymPy expressions into Rust expressions. A complete code generator, which uses `rust_code` extensively, can be found in `sympy.utilities.codegen`. The `codegen` module can be used to generate complete source code files. )AnyDict)SRationalFloatLambda) CodePrinterZfloorZceilingZceilZAbsabssignZsignumZPowcC |tj kSNrOnebaseexpr5/usr/lib/python3/dist-packages/sympy/printing/rust.pyG rZrecipcCs |tjkSr rZHalfrrrrrHs ZsqrtcCr r rrrrrrIrz sqrt().recipcCs|tddkS)N)rrrrrrJZcbrtcCs|tjdkS)Nrr rrrrrKrZexp2rcC|jSr  is_integerrrrrrLsZpowircCs|j Sr rrrrrrMsZpowfrcCdS)NTr)rrrrrNslogZlnZMaxmaxZMinminZsinZcosZtanZasinZacosZatanZatan2Zsinhcoshtanhasinhacoshatanh)r"r#r$r%r&)4ZabstractZalignofasZbecomeZboxbreakconstcontinueZcrateZdoelseenumZexternfalsefinalfnforifimplinZletZloopZmacromatchmodmoveZmutZoffsetofoverrideZprivprocZpubZpurerefreturnZSelfselfZsizeofZstaticstructsuperZtraittruetypeZtypeofZunsafeZunsizedZuseZvirtualwherewhileyieldc sleZdZdZdZdZdddiddedd dd Zifd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd ZdOfd!d" ZdOfd#d$ Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.ZdOd/d0ZdOd1d2ZdOd3d4ZdOd5d6ZdOd7d8ZdOd9d:ZdOd;d<Z dOd=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&fdIdJZ'dKdLZ(dMdNZ)Z*S)PRustCodePrinterz?A printer to convert python expressions to strings of Rust codeZ _rust_codeZRustNautoTF_) ZorderZ full_precZ precisionuser_functionsZhumancontract dereferenceZerror_on_reservedZreserved_word_suffixinlinecCsNt||tt|_|di}|j|t|dg|_tt|_dS)NrGrI) r__init__dictknown_functionsgetupdateset _dereferencereserved_words)r;settingsZ userfuncsrrrrKs    zRustCodePrinter.__init__cCs|dS)Nr)r;prrr_rate_index_positionz$RustCodePrinter._rate_index_positioncCd|S)Nz%s;r)r;Z codestringrrr_get_statementrWzRustCodePrinter._get_statementcCrX)Nz// %sr)r;textrrr _get_commentrWzRustCodePrinter._get_commentcCs d||fS)Nzconst %s: f64 = %s;r)r;namevaluerrr_declare_number_const z%RustCodePrinter._declare_number_constcC ||Sr ) indent_code)r;linesrrr _format_codes zRustCodePrinter._format_codecs |j\}fddt|DS)Nc3s&|]}tD]}||fVqqdSr )range).0ijcolsrr s$z;RustCodePrinter._traverse_matrix_indices..)shaperd)r;matZrowsrrhr_traverse_matrix_indicess z(RustCodePrinter._traverse_matrix_indicesc CsXg}g}d}|D]}||||||j||jdd|dq||fS)Nz#for %(var)s in %(start)s..%(end)s {r)varstartend})append_printlowerupper)r;indicesZ open_linesZ close_linesZ loopstartrfrrr_get_loop_opening_endings  z(RustCodePrinter._get_loop_opening_endingcCs>t|jdkrd||dS|jr|j|ddS||S)Nr()T)_type)lenargsrsZ is_numberr;exprrrr_print_caller_vars  z!RustCodePrinter._print_caller_varcCsD|jj|jvr|j|jj}d}d}t|tr|}n|D] \}}}||jr(nq|dur|dkrSd||jd|t|jdkrL||jdddndd}|S|dkrfd ||jd|d }|S|d kryd ||jd|d }|Sd |||jdd }|SdSt |drt|j t r| |j |jS| |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 Nrz%(var)s.%(method)s(%(args)s)r, )rnmethodr|rz%(var)s.%(method)s())rnrrz%(func)s(%(args)s))funcr|_imp_)r__name__rM isinstancestrr|rr{Z stringifyhasattrrrrs_print_not_supported)r;r~Z cond_funcrZstylecondretrrr_print_FunctionsN   &   zRustCodePrinter._print_FunctioncCs:|jjr|jjst|t|j|j}||S||Sr )rrrr?rrsrr}rrr _print_PowPs  zRustCodePrinter._print_Powct|}|r |dS|S)NZ_f64)r= _print_Floatr;r~rzr __class__rrrV zRustCodePrinter._print_Floatcr)NZ_i32)r=_print_Integerrrrrr]rzRustCodePrinter._print_IntegercCs"t|jt|j}}d||fS)Nz %d_f64/%d.0)intrUq)r;r~rUrrrr_print_Rationalds zRustCodePrinter._print_RationalcCs,||j}||j}|j}d|||S)Nz{} {} {})rslhsrhsZrel_opformat)r;r~lhs_coderhs_codeoprrr_print_Relationalhs  z!RustCodePrinter._print_RelationalcCs`|j}tj}tj}tt|jD]}||j||7}|||9}qd||j j ||fS)N%s[%s]) rkrZZerorreversedrdZrankrvrsrlabel)r;r~Zdimselemoffsetrfrrr_print_IndexednszRustCodePrinter._print_IndexedcCs|jjSr )rr\r}rrr _print_IdxxrWzRustCodePrinter._print_IdxcCrr )r\r}rrr _print_Dummy{szRustCodePrinter._print_DummycCr)NErr;r~rzrrr _print_Exp1~zRustCodePrinter._print_Exp1cCr)NZPIrrrrr _print_PirzRustCodePrinter._print_PicCr)NZINFINITYrrrrr_print_InfinityrzRustCodePrinter._print_InfinitycCr)NZ NEG_INFINITYrrrrr_print_NegativeInfinityrz'RustCodePrinter._print_NegativeInfinitycCr)Nr>rrrrr_print_BooleanTruerz"RustCodePrinter._print_BooleanTruecCr)Nr-rrrrr_print_BooleanFalserz#RustCodePrinter._print_BooleanFalsecCs t|Sr )rrtrrrr _print_boolr_zRustCodePrinter._print_boolcCr)NZNANrrrrr _print_NaNrzRustCodePrinter._print_NaNcCs|jdjdkr tdg}t|jD]G\}\}}|dkr(|d||n#|t|jdkr>|dkr>|dd7<n |dd||7<||}|||d q|jd red |Sd |S) NTzAll 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) {rz else {z else if (%s) {rqrJ  ) r|r ValueError enumeraterrrsr{ _settingsjoin)r;r~rbrfecZcode0rrr_print_Piecewises      z RustCodePrinter._print_PiecewisecCs:ddlm}||jd|jdf|jddf}||S)Nr) PiecewiserrT)Zsympy.functionsrr|rs)r;r~rZ _piecewiserrr _print_ITEs $ zRustCodePrinter._print_ITEcs.|jdkrddfdd|DStd)Nrz[%s]rc3s|]}|VqdSr )rs)rear;rrrjsz4RustCodePrinter._print_MatrixBase..zLFull Matrix Support in Rust need Crates (https://crates.io/keywords/matrix).)rirr)r;Arrr_print_MatrixBases z!RustCodePrinter._print_MatrixBasecCr`r )r)r;rlrrr_print_SparseMatrixs z#RustCodePrinter._print_SparseMatrixcCs"d|j|j|j|jjdfS)Nrr)parentrgrfrkr}rrr_print_MatrixElementsz$RustCodePrinter._print_MatrixElementcs"t|}||jvrd|S|S)Nz(*%s))r= _print_SymbolrQ)r;r~r\rrrrs  zRustCodePrinter._print_SymbolcCshddlm}|j}|j}|jdr!||s||r!|||S||}||}|d||fS)Nr) IndexedBaserHz%s = %s) Zsympy.tensor.indexedrrrrZhasZ_doprint_loopsrsrY)r;r~rrrrrrrr_print_Assignments    z!RustCodePrinter._print_Assignmentc st|tr||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }t|D])\}} | dksE| d krK|| q9|||8}|d ||| f|||7}q9|S) z0Accepts a string of code or a list of code linesTrz ){rxz{ z( )rqrycSsg|]}|dqS)z )lstriprelinerrr sz/RustCodePrinter.indent_code..c g|] }ttt|jqSr)ranymapendswithr) inc_tokenrrrs crr)rrr startswithr) dec_tokenrrrsrrz%s%s)rrra splitlinesrrrr) r;codeZ code_linesZtabZincreaseZdecreaseZprettylevelnrr)rrrras*     zRustCodePrinter.indent_code)F)+r __module__ __qualname____doc__Z printmethodlanguagerPZ_default_settingsrKrVrYr[r^rcrmrwrrrrrrrrrrrrrrrrrrrrrrrrrra __classcell__rrrrrCsb   3           rCNcKst|||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()]; )rCZdoprint)r~Z assign_torSrrr rust_codesmrcKstt|fi|dS)z3Prints Rust representation of the given expression.N)printr)r~rSrrrprint_rust_codehsrr )rtypingrrZ sympy.corerrrrZsympy.printing.codeprinterrrMrRrCrrrrrrst!         !"#$%&'+,k6 " p