B [bS4@sdZddlmZmZddlmZmZmZmZm Z ddl m Z m Z ddl mZmZddlmZddd d d d d ddddddddddddfddddfddddfddddfd dd!d"fd#dd$d%fd&dd'd%fgd(dd)dfgd*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdC*ZdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwg4ZGdxdydyeZdd{d|Zd}d~ZdzS)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. )print_functiondivision)SnumbersRationalFloatLambda) string_typesrange) CodePrinter Assignment) precedenceZis_nanZ is_infiniteZ is_finiteZ is_normalZclassifyfloorZceilroundZtruncZfractabsZsignumZis_sign_positiveZis_sign_negativeZmul_addcCs |tj kS)N)rOne)baseexpr2lib/python3.7/site-packages/sympy/printing/rust.pyIsrZrecipcCs |tjkS)N)rHalf)rrrrrrJsZsqrtcCs |tj kS)N)rr)rrrrrrKsz sqrt().recipcCs|tddkS)N)r)rrrrrrLsZcbrtcCs|tjdkS)Nr)rr)rrrrrrMsZexp2rcCs|jS)N) is_integer)rrrrrrNsZpowircCs|j S)N)r)rrrrrrOsZpowfcCsdS)NTr)rrrrrPsrZlnlogZlog2Zlog10Z to_degreesZ to_radiansmaxminZhypotsincostanasinacosatanatan2Zsin_cosZexp_m1Zln_1psinhcoshtanhasinhacoshatanh)*r,r,r,r,rZceilingr,r,r,ZAbsZsignr,r,r,ZPowrrr,r,r,r,r,ZMaxZMinr,rr r!r"r#r$r%r,r,r,r&r'r(r)r*r+ZabstractZalignofasZbecomeZboxbreakZconstcontinueZcrateZdoelseenumZexternfalsefinalfnforifimplinZletZloopZmacromatchmodZmoveZmutZoffsetofoverrideZprivprocZpubZpurerefreturnZSelfselfZsizeofZstaticZstructsuperZtraittruetypeZtypeofZunsafeZunsizedZuseZvirtualwherewhileyieldc s|eZdZdZdZdZdddiddedd dd Zifd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd ZdMfd!d" ZdNfd#d$ Zd%d&Zd'd(Zd)d*Zd+d,ZdOd-d.ZdPd/d0ZdQd1d2ZdRd3d4ZdSd5d6ZdTd7d8ZdUd9d:ZdVd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%e$Z#Z%Z&Z'Z(Z)fdGdHZ*dIdJZ+dKdLZ,Z-S)WRustCodePrinterz?A printer to convert python expressions to strings of Rust codeZ _rust_codeZRustNautoTF_) orderZ full_precZ precisionuser_functionsZhumancontract dereferenceZerror_on_reservedZreserved_word_suffixinlinecCsNt||tt|_|di}|j|t|dg|_tt|_dS)NrKrM) r __init__dictknown_functionsgetupdateset _dereferencereserved_words)r?settingsZ userfuncsrrrrOs     zRustCodePrinter.__init__cCs|dS)Nr)r?prrr_rate_index_positionsz$RustCodePrinter._rate_index_positioncCsd|S)Nz%s;r)r?Z codestringrrr_get_statementszRustCodePrinter._get_statementcCsd|S)Nz// %sr)r?textrrr _get_commentszRustCodePrinter._get_commentcCs d||fS)Nzconst %s: f64 = %s;r)r?namevaluerrr_declare_number_constsz%RustCodePrinter._declare_number_constcCs ||S)N) indent_code)r?linesrrr _format_codeszRustCodePrinter._format_codecs |j\}fddt|DS)Nc3s$|]}tD]}||fVqqdS)N)r ).0ij)colsrr sz;RustCodePrinter._traverse_matrix_indices..)shaper )r?ZmatZrowsr)rgr_traverse_matrix_indicess z(RustCodePrinter._traverse_matrix_indicesc Cs\g}g}d}xF|D]>}||||||j||jdd|dqW||fS)Nz#for %(var)s in %(start)s..%(end)s {r)varstartend})append_printlowerupper)r?indicesZ open_linesZ close_linesZ loopstartrerrr_get_loop_opening_endings  z(RustCodePrinter._get_loop_opening_endingcCsBt|jdkr d||dS|jr4|j|ddS||SdS)Nr()T)_type)lenargsrpZ is_number)r?exprrrr_print_caller_vars z!RustCodePrinter._print_caller_varcCsJ|jj|jkr|j|jj}d}d}t|tr6|}n x|D]\}}}||jr x.exp()) 4. func(args), function with arguments Nrz%(var)s.%(method)s(%(args)s)rz, r,)rkmethodryrz%(var)s.%(method)s())rkr|rz%(func)s(%(args)s))funcry_imp_)r}__name__rQ isinstancestrryr{rxZ stringifyhasattrr~rrpZ_print_not_supported)r?rzZ cond_funcr}Zstylecondretrrr_print_Functions<    0  zRustCodePrinter._print_FunctioncCs:|jjr0|jjs0t|t|j|j}||S||S)N)rrrrBrrpr)r?rzrrr _print_PowRs zRustCodePrinter._print_Powcs$tt||}|r|dS|SdS)NZ_f64)r@rF _print_Float)r?rzrwr) __class__rrrXszRustCodePrinter._print_Floatcs$tt||}|r|dS|SdS)NZ_i32)r@rF_print_Integer)r?rzrwr)rrrr_szRustCodePrinter._print_IntegercCs"t|jt|j}}d||fS)Nz %d_f64/%d.0)intrYq)r?rzrYrrrr_print_RationalfszRustCodePrinter._print_RationalcCsd|j}tj}tj}x4tt|jD]"}||j||7}|||9}q"Wd||j j ||fS)Nz%s[%s]) rirZZerorreversedr Zrankrsrprlabel)r?rzZdimselemoffsetrerrr_print_IndexedjszRustCodePrinter._print_IndexedcCs|jjS)N)rr^)r?rzrrr _print_IdxtszRustCodePrinter._print_IdxcCs|jS)N)r^)r?rzrrr _print_DummywszRustCodePrinter._print_DummycCsdS)NEr)r?rzrwrrr _print_Exp1zszRustCodePrinter._print_Exp1cCsdS)NZPIr)r?rzrwrrr _print_Pi}szRustCodePrinter._print_PicCsdS)NZINFINITYr)r?rzrwrrr_print_InfinityszRustCodePrinter._print_InfinitycCsdS)NZ NEG_INFINITYr)r?rzrwrrr_print_NegativeInfinitysz'RustCodePrinter._print_NegativeInfinitycCsdS)NrAr)r?rzrwrrr_print_BooleanTruesz"RustCodePrinter._print_BooleanTruecCsdS)Nr2r)r?rzrwrrr_print_BooleanFalsesz#RustCodePrinter._print_BooleanFalsecCs t|S)N)rrq)r?rzrwrrr _print_boolszRustCodePrinter._print_boolcCsdS)NZNANr)r?rzrwrrr _print_NaNszRustCodePrinter._print_NaNcCs|jdjdkrtdg}xt|jD]\}\}}|dkrR|d||nF|t|jdkr~|dkr~|dd7<n|dd||7<||}|||d q(W|jd rd |Sd |SdS) 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) {rnrN  ) ryr ValueError enumeraterorprx _settingsjoin)r?rzrbreecZcode0rrr_print_Piecewises    z RustCodePrinter._print_PiecewisecCs:ddlm}||jd|jdf|jddf}||S)Nr) PiecewiserrT)Zsympy.functionsrryrp)r?rzrZ _piecewiserrr _print_ITEs $zRustCodePrinter._print_ITEcCs"d|j|j|j|jjdfS)Nz%s[%s]r)parentrfreri)r?rzrrr _print_MatrixszRustCodePrinter._print_Matrixcs2|jdkr&ddfdd|DStddS)Nrz[%s]z, c3s|]}|VqdS)N)rp)rda)r?rrrhsz4RustCodePrinter._print_MatrixBase..zLFull Matrix Support in Rust need Crates (https://crates.io/keywords/matrix).)rgrr)r?Ar)r?r_print_MatrixBases z!RustCodePrinter._print_MatrixBasecCs"d|j|j|j|jjdfS)Nz%s[%s]r)rrfreri)r?rzrrr_print_MatrixElementsz$RustCodePrinter._print_MatrixElementcs*tt||}||jkr"d|S|SdS)Nz(*%s))r@rF _print_SymbolrU)r?rzr^)rrrrs zRustCodePrinter._print_SymbolcCslddlm}|j}|j}|jdrB||s6||rB|||S||}||}|d||fSdS)Nr) IndexedBaserLz%s = %s) Zsympy.tensor.indexedrlhsrhsrZhasZ_doprint_loopsrpr[)r?rzrrrZlhs_codeZrhs_coderrr_print_Assignments     z!RustCodePrinter._print_Assignmentc st|tr$||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }x^t|D]R\}} | dks| d kr|| qt|||8}|d ||| f|||7}qtW|S) z0Accepts a string of code or a list of code linesTr,z ){ruz{ z( )rnrvcSsg|]}|dqS)z )lstrip)rdlinerrr sz/RustCodePrinter.indent_code..cs g|]}ttt|jqSr)ranymapendswith)rdr) inc_tokenrrrscs g|]}ttt|jqSr)rrr startswith)rdr) dec_tokenrrrsrrz%s%s)rr ra splitlinesrrro) r?codeZ code_linesZtabZincreaseZdecreaseZprettylevelnrr)rrrras(     zRustCodePrinter.indent_code)F)F)F)F)F)F)F)F)F)F).r __module__ __qualname____doc__Z printmethodZlanguagerTZ_default_settingsrOrZr[r]r`rcrjrtr{rrrrrrrrrrrrrrrrrrrrrZ_print_DenseMatrixZ_print_MutableDenseMatrixZ_print_ImmutableMatrixZ_print_ImmutableDenseMatrixrrra __classcell__rr)rrrFs^   3           rFNcKst|||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()]; )rFZdoprint)rzZ assign_torWrrr rust_codesmrcKstt|f|dS)z3Prints Rust representation of the given expression.N)printr)rzrWrrrprint_rust_codeosr)N)rZ __future__rrZ sympy.corerrrrrZsympy.core.compatibilityr r Zsympy.printing.codeprinterr r Zsympy.printing.precedencer rQrVrFrrrrrr s       ;' p