\hRSSKJr SSKJr SSKJr SSKJrJrJ r J r J r J r SSK Jr SSKJrJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJr SS KJrJ r "SS5r!"SS\"5r#"SS\$5r%Sr&"SS\5r'SSjr(Sr)S Sjr*Sr+S!Sjr,S Sjr-Sr.g)") annotations)Anywraps)AddMulPowSsympifyFloat)Basic)ExprUnevaluatedExpr)Lambda) _keep_coeff)default_sort_key)Symbol)re) StrPrinter) precedence PRECEDENCEc$\rSrSrSrSrSrSrg)requiresz9Decorator for registering requirements on print methods. c XlgN_req)selfkwargss R/var/www/auris/envauris/lib/python3.13/site-packages/sympy/printing/codeprinter.py__init__requires.__init__s c6^^UU4Sjn[T5"U5$)Nc>TRR5Hup4[X5RU5 M! T"U/UQ70UD6$r)ritemsgetattrupdate)self_argsr kvmethodrs r!_method_wrapper*requires.__call__.._method_wrappersB )!((+*%1$1&1 1r$r)rr.r/s`` r!__call__requires.__call__s 2V}_--r$rN)__name__ __module__ __qualname____firstlineno____doc__r"r1__static_attributes__r$r!rrsD.r$rc\rSrSrSrSrg)AssignmentErrorz9 Raised if an assignment variable for a loop is missing. r9Nr3r4r5r6r7r8r9r$r!r;r;  r$r;c\rSrSrSrSrg)PrintMethodNotImplementedError%z8 Raised if a _print_* method is missing in the Printer. r9Nr=r9r$r!r@r@%r>r$r@c[U[5(aSSKJn U"SU56$[U[5(a[ SU55$U$)Nr)Listc38# UHn[U5v M g7fr_convert_python_lists.0es r! (_convert_python_lists...s<1+A..c38# UHn[U5v M g7frrErGs r!rJrK0s;s!*1--srL) isinstancelistsympy.codegen.abstract_nodesrCtuple)argrCs r!rFrF+sF#t5<<== C  ;s;;; r$c :^\rSrSr%SrSSSS.rSSS S S S S SS .rS \S'0SS/4_SS/4_SS/4_SS/4_SS/4_SS/4_SS/4_SS/4_SS/4_SS /4_S!S /4_S"S /4_S#S$/4_S%S&/4_S'S&/4_S(S$/4_S)SS*/4_0S+S,/4_S-S$/4_S.S$S*/4_S/S0/4_S1S$S*/4_S2S$S*/4_S3S$/4_S4S,/4_S5S*/4_S6S*/4_S7S*/4_S8S9/4_S:S9/4_S;SS?/4_S@S?S$/4_ESAS*/40ErSnU4SBjjr SCr SnSDjr SnSEjr SFr SGrSHrSIrSJrSKrSLrSMrSNrSOrSPrSQrSRrSSrSTrSUrSVrSWrU4SXjrSYr SZr!\!r"S[r#Sr$S\r%S]r&S^r'S_r(S`r)Sar*Sbr+Scr,Sdr-Ser.Sfr/Sgr0Shr1Sir2Sjr3Skr4Slr5\5r6\5r7\5r8\5r9\5r:\5r;\5r<\5r=\5r>\5r?\5r@\5rA\5rB\5rC\5rD\5rE\5rF\5rG\5rH\5rI\5rJ\5rKSmrLU=rM$)o CodePrinter5z. The base class for code-printing subclasses. z&&z||!)andornotNautoF_T)order full_precerror_on_reservedreserved_word_suffixhumaninlineallow_unknown_functionsstrictzdict[str, Any]_default_settingscottancscsinseccosacotatanacscasinasecacoscothexpcschsechacothlogacschasechcatalangamma fibonaccisqrtlucasbetasinc PiecewiseModfloor factorial factorial2 subfactorial uppergammaRisingFactorialFallingFactorialbinomialfracMaxMin Heavisideerf2erferfcLiliEi dirichlet_etazeta riemann_xiSingularityFunctionc>[TU]US9 URRSS5S:Xa,URRSS5S:HURS'[ US5(d[ 5Ulgg)N)settingsrcTr`reserved_words)superr" _settingsgethasattrsetr)rr __class__s r!r"CodePrinter.__init__tsm (+ >>  h - 5'+~~'9'9'4'HD'PDNN8 $t-.."%%D /r$c0UR[S5$)Nc[U[5(a URSR(aU$[ U5$)Nr)rNrr+is_realr)rRs r!5CodePrinter._handle_UnevaluatedExpr..}s<: 4"4"&)hhqk&9&9-0-G?A#w-Gr$)replacerrexprs r!_handle_UnevaluatedExpr#CodePrinter._handle_UnevaluatedExpr|s||B!GH Hr$c@^^ ^ ^ ^SSKJm SSKJm Jm U U U UU4Sjm[ U5nT"X5nTR U5n[5Tl[5Tl TRU5R5nTRS(Ga/nTR(aURTRSRTR 555 [#TR[$S9H6nURTR['U5R(55 M8 [#TR[$S9H%upVURTR+XV55 M' XC-nTR-U5nSR/U5nO`TR-U5nTRVV s1sHupUTRU 54iM n nn U TRSR/U54n[5Tl[5Tl U$s sn nf) aL Print the expression as code. Parameters ---------- expr : Expression The expression to be printed. assign_to : Symbol, string, MatrixSymbol, list of strings or Symbols (optional) If provided, the printed code will set the expression to a variable or multiple variables with the name or names given in ``assign_to``. r MatrixSymbol) CodeBlock Assignmentc r>Uc [U5$[U[[45(an[ U5[ U5:wa-[ SR [ U5[ U555eT"[X5VVs/sH up#T"X#5PM snn6$[U[5(a1UR(aT"U/URQ76nOX[U5nOL[U[5(d7[SR [T5R[U555eT"X5$s snnf)Nz;Failed to assign an expression of length {} to {} variablesz%{} cannot assign to object of type {})r rNrOrQlen ValueErrorformatzipstr is_Matrixshaperr TypeErrortyper3) r assign_tolhsrhsrrr_handle_assign_tors r!r.CodePrinter.doprint.._handle_assign_tos t}$)dE]33t9I.$%b%i%ijmnrjsuxzCvD&EFF sSWOc"dOc83#4S#>Oc"dee)S))>> ,Y D DI &y 1I 511 G N NT ++T)_!>??i. .#esD3 r`zNot supported in {}:key )"sympy.matrices.expressions.matexprrsympy.codegen.astrrrFrr_not_supported_number_symbols_print splitlinesrappend _get_commentrlanguagesortedrrr3_declare_number_const _format_codejoin)rrrlines frontlinesnamevalueresultr,r-num_symsrrrrs` @@@@r!doprintCodePrinter.doprints D; / /"%T* 1++D1"e"u D!,,. >>' " "J""!!$"3"3.55dmmD#FG"4#6#6C@D%%d&7&7T 8K8K&LMA%d&:&:D !!$"<">  j$ / / >224CG/5GGdWoG";;GD 7?%%dC,?@D%%dA.Dkk),    LL "$** T+JK LL  LL #A!U##..q7*.*G*G+' $JD0WAaffh0W07 > 1 >1? 2NPP%,"1 D#FF88I..",.B#CC X. Z0,79K9K d"2:4 5 T%8%8%>? [1 Y/E' TyyG1X>s #I+? I0 cSSKJn U"U5upEU"U5upeU(a U(dUnXF:wa[SU-5eURXB5$)Nr) get_indicesz2lhs indices must match non-dummy rhs indices in %s)rrrr)rrrrrindsjunklindss r!r#CodePrinter._get_expression_indicess[,!$' !),  E >)+/01 1##E55r$c*^ SSKJn U(d/$0m UHnST U'M URU5nUH>n[UR5H"upxT U==UR U5- ss'M$ M@ [UU 4SjS9$![ a MEf=f)Nr)Indexedc>TU$rr9)x score_tables r!r-CodePrinter._sort_optimized..5s [^r$r)sympy.tensor.indexedratoms enumerater_rate_index_positionKeyErrorr) rrrriarraysarrpindrs @r!rCodePrinter._sort_optimized s0I AKNG$C#CKK0$(A(A!(DD$1g#;<< sB BBc[S5e)zfunction to calculate score based on position among indices This method is used to sort loops in an optimized order, see CodePrinter._sort_optimized() =This function must be implemented by subclass of CodePrinter.r)rrs r!r CodePrinter._rate_index_position7s "#=> >r$c[S5e)z1Formats a codestring with the proper line ending.r r )r codestrings r!rCodePrinter._get_statement@!#=> >r$c[S5e)z#Formats a text string as a comment.r r )rrs r!rCodePrinter._get_commentErr$c[S5e)z3Declare a numeric constant at the top of a functionr r )rrrs r!r!CodePrinter._declare_number_constJrr$c[S5e)zvTake in a list of lines of code, and format them accordingly. This may include indenting, wrapping long lines, etc...r r )rrs r!rCodePrinter._format_codeOs"#=> >r$c[S5e)zGReturns a tuple (open_lines, close_lines) containing lists of codelinesr r )rrs r!r$CodePrinter._get_loop_opening_endingVs"#=> >r$cURRS5(aSUR-$SURUR4-$)NDummy_r[z%s_%d)r startswith dummy_indexrs r! _print_DummyCodePrinter._print_Dummy\s? 99   ) )? "dii)9)9:: :r$c8URUR5$r)rlabelrs r! _print_IdxCodePrinter._print_Idxbs{{4::&&r$cSRURVs/sHo RU5PM sn5$s snf)Nr)rr+r)rrrs r!_print_CodeBlockCodePrinter._print_CodeBlockes-yy$))<)Q++a.)<==# UHnTRU5v M g7frrrHrRrs r!rJ9CodePrinter._print_AugmentedAssignment..s H*G3dkk#*G!)rrrrrop)rrr<r=s` r!_print_AugmentedAssignment&CodePrinter._print_AugmentedAssignments[;;txx(;;txx("":#4#4 H8WWh*G H$JK Kr$cr^UR<SSRU4SjUR55<S3$)N(, c3F># UHnTRU5v M g7frrBrCs r!rJ2CodePrinter._print_FunctionCall..sF3ECt{{3''3ErE))rr function_argsrs` r!_print_FunctionCallCodePrinter._print_FunctionCalls. II IIF43E3EF GI Ir$c8URUR5$r)rsymbolrs r!_print_VariableCodePrinter._print_Variables{{4;;''r$c>[TU]U5nX R;aAURS(aSn[ UR U55eX RS-$U$)Nr^zVThis expression includes the symbol "{}" which is a reserved keyword in this language.r_)r _print_Symbolrrrr)rrrmsgrs r!rWCodePrinter._print_Symbols^w$T* && &~~12< D!122..)?@@ @Kr$cdXR;=(d [USRU5S5$)z}Check if function ``name`` is either a known function or has its own printing method. Used to check if rewriting is possible.z _print_{}F)known_functionsr(r)rrs r! _can_printCodePrinter._can_prints.+++]wt[=O=OPT=UW\/]]r$c 6^URRTR;aTRURRn[U[5(a$U<STR UR S5<S3$UHup4U"UR 6(dM O Wb1U"UR Vs/sHnTRUS5PM sn6$O[US5(aG[UR[5(a(TRUR"UR 65$URRTR;a{TRURRupgTRU5(a@[U4SjU55(a&STRUR!U55-S-$UR"(aqTR$R'SS5(aPTRUR5<SSR)[+TRUR 55<S3$TR-U5$s snf![a' U<STR UR S5<S3s$f=f) NrJrKrNr_imp_c3F># UHnTRU5v M g7fr)r\)rHrrs r!rJ.CodePrinter._print_Function..s0Y[1C1C[rErbF)funcr3r[rNr stringifyr+ parenthesizerrr_rr_rewriteable_functionsr\allrewrite is_Functionrrrmap_print_not_supported)rr cond_funccondrbitemtarget_f required_fss` r!_print_FunctionCodePrinter._print_Functions 99  !5!5 5,,TYY-?-?@I)S))#,dnnTYY.MNN"+JDTYY''#,#R#TYY%WYTd&7&7a&@Y%WXX$ T7 # # 4::v(F(F;;tzz49956 6 YY  4#>#> >$($?$? @R@R$S !Hx((S0Y[0Y-Y-YT[[h)?@@3FF    2 23Le T T#{{4995tyyT[[RVR[R[A\7]^ ^,,T2 2&X$R+/ 41PQQRs$'I'7I"I'"I''.JJc6URtp#URH6nUR(aM[SURR-5e SUR R-n[ XS5nUc^URRSS5(a,[S[U5S[U53SU3-S-5eURU5$[U5nURVs/sHoUPM n nU"URU 5$s snf) NzL%s._print_Derivative(...) only supports functions with symbols as arguments.z_print_Derivative_%srcFUnsupported by : z Printer has no method: V Set the printer option 'strict' to False in order to generate partially printed code.) r+ is_Symbolrrr3rbr(rrr@rrjdict) rrobjwrt_order_pairsfunc_arg meth_namepmethordersrR seq_orderss r!_print_DerivativeCodePrinter._print_Derivatives $ H%%% !o!%!8!8"9::!+SXX->->> . =~~!!(E224%d4j\DJ<@/ {;<mn ,,T2 2o&-0XX6XcSkX 6SXXz**7s3Dc JURRSS5(a6UR[UR URS555$UR R U[UR URS5545 [U5$)NraF precision)rrrr evalfraddrrs r!_print_NumberSymbolCodePrinter._print_NumberSymbols >>  h . .;;uTZZ{0K%LMN N  $ $ddjj !<=>&@ At9 r$c$URU5$rrrs r!_print_CatalanCodePrinter._print_Catalan''--r$c$URU5$rrrs r!_print_EulerGammaCodePrinter._print_EulerGammarr$c$URU5$rrrs r!_print_GoldenRatioCodePrinter._print_GoldenRatiorr$c$URU5$rrrs r!_print_TribonacciConstant%CodePrinter._print_TribonacciConstantrr$c$URU5$rrrs r! _print_Exp1CodePrinter._print_Exp1rr$c$URU5$rrrs r! _print_PiCodePrinter._print_Pirr$c^^[U5mSTRS-RUU4Sj[UR[ S955$)N %s rWc3H># UHnTRUT5v M g7frrdrHaPRECrs r!rJ)CodePrinter._print_And..s)6B@A7;6G6G46P6P@"rr _operatorsrrr+rrrrs` @r! _print_AndCodePrinter._print_AndsK$//556B /?@6BB Br$c^^[U5mSTRS-RUU4Sj[UR[ S955$)NrrXc3H># UHnTRUT5v M g7frrrs r!rJ(CodePrinter._print_Or..s)5B@A6:5F5Fq$5O5O@rrrrs` @r! _print_OrCodePrinter._print_OrsK$..445B /?@5BB Br$c^^TRRS5cTRUR55$[ U5mSTRS-R UU4SjUR 55$)Nxorrc3H># UHnTRUT5v M g7frrrs r!rJ)CodePrinter._print_Xor..s(6$"A7;6G6G46P6P"rrrrto_nnfrrr+rs` @r! _print_XorCodePrinter._print_Xor si ??  u % -;;t{{}- -$//556$6$$ $r$c^^TRRS5cTRUR55$[ U5mSTRS-R UU4SjUR 55$)N equivalentrc3H># UHnTRUT5v M g7frrrs r!rJ0CodePrinter._print_Equivalent..s*=$"A>B=N=NqRV=W=W"rrrs` @r!_print_EquivalentCodePrinter._print_Equivalentsi ??  | , 4;;t{{}- -$66<<=$=$$ $r$cv[U5nURSURURSU5-$)NrYr)rrrdr+rs r! _print_NotCodePrinter._print_Nots5$u%(9(9$))A,(MMMr$c@URUR55$r)rrrs r!_print_BooleanFunction"CodePrinter._print_BooleanFunctions{{4;;=))r$c:SUR"UR6-$)Nz isnan(%s)rr+r,s r! _print_isnanCodePrinter._print_isnan T[[#((333r$c:SUR"UR6-$)Nz isinf(%s)rr,s r! _print_isinfCodePrinter._print_isinf#rr$c :[U5nUR5up4US:a[U*U5nSnOSn/n/n/nURS;aUR 5n O[ R "U5n U GH9n U R(GaU R(GaU RR(aU RR(aU RS:wa1UR[U RU R*SS95 M[U R SR 5S:wa0[#U R[ 5(aURU 5 UR[U RU R*55 GM(URU 5 GM< U=(d [$R&/n[U5S:Xa1US:Xa+UR)USS [*S [*S --5/n O UV s/sHoR)X5PM n n UV s/sHoR)X5PM n n UHPn U RU;dMS XR-U R5-XR-U R5'MR U(dUS R/U 5-$[U5S:XaUS R/U 5-S-U S-$US R/U 5-SS R/U 5--$s sn fs sn f)Nr-)oldnoneF)evaluateg?r rz(%s)*/z/(%s))r as_coeff_Mulrr\as_ordered_factorsr make_argsis_commutativeis_Powrr is_Rational is_negativerr baserr+rNr Onerdrindexr)rrprecr8rIsignrb pow_parenr+rma_strrb_strs r! _print_MulCodePrinter._print_Mul&sw$  " q5r1%DDD   ::_ ,**,D==&DD"""t{{{txx7K7KPTPXPXPdPd88r>HHSTXXIFG499Q<,,-2z$))S7Q7Q!((.HHSTXXI67 L!%% q6Q;43; &&qtS*U2CJuDU2U-VWXE9:;A&&q/E;567Q""1+Q7DyyA~,2U77499;M5N,Nggdii()#((5/) ) Vq[#((5/)C/%(: :#((5/)Gchhuo,EE E<7s L1Lc URRSS5(a&[S[U5S[U53S-5eURR U5 URU5$![ a Nf=f)NrcFrsrtru)rrr@rrrr emptyPrinterrs r!rj CodePrinter._print_not_supported`s >>  h . .0!$t*RT |<ij      # #D )  &&   s A55 BB)rrrr)Nr3r4r5r6r7rrd__annotations__rer"rrrrrrrrrrrrr!r$r)r-r0r>rGrPrTrWr\rp _print_Exprr_print_Heavisiderrrrrrrrrrrrrrrrrj _print_Basic_print_ComplexInfinity_print_ExprCondPair_print_GeometryEntity_print_Infinity_print_Integral_print_Interval_print_AccumulationBounds _print_Limit_print_MatrixBase_print_DeferredVector _print_NaN_print_NegativeInfinity _print_Order _print_RootOf_print_RootsOf_print_RootSum_print_Uniform _print_Unit _print_Wild_print_WildFunction_print_Relationalr8 __classcell__)rs@r!rTrT5s J" ##( )~ $ E2;$ E2;$ E2;$ VRL $ VRL $ VRL $ UBK$ UBK$ UBK$ eR[$ eR[$ eR[$ }$ &"$ fb\$ WbM!$" U[M*#$$ GR=%$& '2'$( 7[M2)$* \2.+$, +7-$. ;- 8/$0 " 1$2 WbM3$4 K$5$6 K$7$8 +r*9$: UBK;$< UBK=$> 4*?$@ 4*A$B fb\C$D 6G9-E$F "K#4G$L(HAFM ^ 6=.>> > > >> ; '>!.#IJK I ( ^ 38"K+*......B B $$N*448Ft '(L1.0*O*O*O 4'L,0%J2'L(M)N)N)N&K&K.,r$rTNc \SSKJn XBR5"U5RX5$)aConverts an expr to a string of c 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. standard : str, optional String specifying the standard. If your compiler supports a more modern standard you may set this to 'c99' to allow the printer to use more math functions. [default='c89']. precision : integer, optional The precision for numbers such as pi [default=17]. 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)] or [(argument_test, cfunction_formater)]. 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 ccode, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> expr = (2*tau)**Rational(7, 2) >>> ccode(expr) '8*M_SQRT2*pow(tau, 7.0/2.0)' >>> ccode(expr, math_macros={}) '8*sqrt(2)*pow(tau, 7.0/2.0)' >>> ccode(sin(x), assign_to="s") 's = sin(x);' >>> from sympy.codegen.ast import real, float80 >>> ccode(expr, type_aliases={real: float80}) '8*M_SQRT2l*powl(tau, 7.0L/2.0L)' 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"), ... (lambda x: x.is_integer, "ABS")], ... "func": "f" ... } >>> func = Function('func') >>> ccode(func(Abs(x) + ceiling(x)), standard='C89', user_functions=custom_functions) 'f(fabs(x) + CEIL(x))' or if the C-function takes a subset of the original arguments: >>> ccode(2**x + 3**x, standard='C99', user_functions={'Pow': [ ... (lambda b, e: b == 2, lambda b, e: 'exp2(%s)' % e), ... (lambda b, e: b != 2, 'pow')]}) 'exp2(x) + pow(3, x)' ``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(ccode(expr, tau, standard='C89')) if (x > 0) { tau = x + 1; } else { tau = 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])) >>> ccode(e.rhs, assign_to=e.lhs, contract=False, standard='C89') '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(ccode(mat, A, standard='C89')) A[0] = pow(x, 2); if (x > 0) { A[1] = x + 1; } else { A[1] = x; } A[2] = sin(x); r)c_code_printers)sympy.printing.crlowerr)rrstandardrrs r!ccoders(D1 >>+ ,X 6 > >t OOr$c .[[U40UD65 g)z0Prints C representation of the given expression.N)printrrrs r! print_ccoder s % ! !"r$c <SSKJn U"U5RX5$)aConverts an expr to a string of fortran 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 DEPRECATED. Use type_mappings instead. The precision for numbers such as pi [default=17]. 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]. source_format : optional The source format can be either 'fixed' or 'free'. [default='fixed'] standard : integer, optional The Fortran standard to be followed. This is specified as an integer. Acceptable standards are 66, 77, 90, 95, 2003, and 2008. Default is 77. Note that currently the only distinction internally is between standards before 95, and those 95 and after. This may change later as more features are added. name_mangling : bool, optional If True, then the variables that would become identical in case-insensitive Fortran are mangled by appending different number of ``_`` at the end. If False, SymPy Will not interfere with naming of variables. [default=True] Examples ======== >>> from sympy import fcode, symbols, Rational, sin, ceiling, floor >>> x, tau = symbols("x, tau") >>> fcode((2*tau)**Rational(7, 2)) ' 8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)' >>> fcode(sin(x), assign_to="s") ' s = 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)]. >>> custom_functions = { ... "ceiling": "CEIL", ... "floor": [(lambda x: not x.is_integer, "FLOOR1"), ... (lambda x: x.is_integer, "FLOOR2")] ... } >>> fcode(floor(x) + ceiling(x), user_functions=custom_functions) ' CEIL(x) + FLOOR1(x)' ``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(fcode(expr, tau)) if (x > 0) then tau = x + 1 else tau = x end if 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])) >>> fcode(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(fcode(mat, A)) A(1, 1) = x**2 if (x > 0) then A(2, 1) = x + 1 else A(2, 1) = x end if A(3, 1) = sin(x) r) FCodePrinter)sympy.printing.fortranrr)rrrrs r!fcodersh4  ! ) )$ ::r$c .[[U40UD65 g)zqPrints the Fortran representation of the given expression. See fcode for the meaning of the optional arguments. N)r rr s r! print_fcoders  % ! !"r$c \SSKJn XBR5"U5RX5$)z#C++ equivalent of :func:`~.ccode`. r)cxx_code_printers)sympy.printing.cxxrrr)rrrrrs r!cxxcoders%4 ^^- .x 8 @ @ QQr$c SSKJn U"U5nURU5n[U[5(a4UR R 5HupVURXV5nM URX5$)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.0*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.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.0) { x + 1 } else { x }, x.sin()]; r)RustCodePrinter) sympy.printing.rustr_rewrite_known_functionsrNrfunction_overridesvaluesrr)rrrrprintersrc_funcdst_funcs r! rust_coder siX4h'G  + +D 1D$")"<"<"C"C"E H<<3D#F ??4 ++r$c .[[U40UD65 g)z3Prints Rust representation of the given expression.N)r r r s r!print_rust_coder" s )D %H %&r$)Nc99r)Nzc++11)/ __future__rtypingr functoolsr sympy.corerrr r r r sympy.core.basicr sympy.core.exprrrsympy.core.functionrsympy.core.mulrsympy.core.sortingrsympy.core.symbolr$sympy.functions.elementary.complexesrsympy.printing.strrsympy.printing.precedencerrr Exceptionr;rr@rFrTrr rrrr r"r9r$r!r2s"77"1&&/$3)< . . i  %8 N -*N -jCPJ#u;p#R r,j'r$