o 8Vad@sddlmZmZmZmZddlmZddlmZm Z m Z m Z m Z m Z mZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZGd d d ZGd ddeZGdddeZ dddZ!ddZ"dddZ#ddZ$d ddZ%dS)!)AnyDictSetTuplewraps)AddExprMulPowSsympifyFloat)Basic)default_sort_key)Lambda) _keep_coeff)Symbol) StrPrinter) precedencec@s eZdZdZddZddZdS)requiresz: Decorator for registering requirements on print methods. cKs ||_dSN)_req)selfkwargsr._method_wrapperr)rr&r'rr%r__call__s zrequires.__call__N)__name__ __module__ __qualname____doc__rr(rrrrrs rc@seZdZdZdS)AssignmentErrorzA Raised if an assignment variable for a loop is missing. N)r)r*r+r,rrrrr-sr-cseZdZdZddddZdddd d ddd Zd d ddZdZfdd ZdZddZdZddZ ddZ ddZ ddZ ddZ ddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zfd:d;Zdd?Z d@dAZ!dBdCZ"dDdEZ#dFdGZ$dHdIZ%dJdKZ&dLdMZ'dNdOZ(dPdQZ)dRdSZ*dTdUZ+dVdWZ,dXdYZ-e-Z.e-Z/e-Z0e-Z1e-Z2e-Z3e-Z4e-Z5e-Z6e-Z7e-Z8e-Z9e-Z:e-Z;e-Ze-Z?e-Z@e-ZAe-ZBe-ZCe-ZDZES)[ CodePrinterz6 The base class for code-printing subclasses. z&&z||!)andornotNautoF_T)orderZ full_precerror_on_reservedreserved_word_suffixhumaninlineallow_unknown_functionsZerfZliZgamma)Zerf2ZLiZbetacs(tj|dt|dst|_dSdS)N)settingsreserved_words)superrhasattrsetr<)rr; __class__rrr@s  zCodePrinter.__init__c s:ddlmddlmmfdd||}t_t_| }j dr{g}jrW|  d jtjtdD] }|  t|jqItjtdD] \}}| ||q^||}|}d |}n|}fd d jD}|jd |f}t_t_|S) a 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 Assignmentcs|durt|St|ttfr1t|t|kr#tdt|t|fddt||DSt|trH|j rC|g|j R}nt |}nt|t sZt dtjt|||S)Nz;Failed to assign an expression of length {} to {} variablescsg|] \}}||qSrr).0lhsrhs)_handle_assign_torr \szBCodePrinter.doprint.._handle_assign_to..z%{} cannot assign to object of type {})r isinstancelisttuplelen ValueErrorformatzipstrZ is_Matrixshaperr TypeErrortyper))expr assign_torErDrCrIrrrrIVs    z.CodePrinter.doprint.._handle_assign_tor8zNot supported in {}:key csh|] \}}||fqSr_print)rFr#r$rrr sz&CodePrinter.doprint..)"sympy.matrices.expressions.matexprrCsympy.codegen.astrDrEr?_not_supported_number_symbolsr] splitlines _settingsappend _get_commentrPlanguagesortedrRrUr)_declare_number_const _format_codejoin) rrVrWlinesZ frontlinesnamevalueresultZnum_symsrrXrdoprintFs4       zCodePrinter.doprintc Cs|jddrddlm}|||}||}ng}d|fi}||\}}d|vr5t|t|d}nt|d}| |} g} || krb| ||durX| d| |f}| || ||D]n} t | tr|| |}||\} } || D]U}||vrdd||Ddd||Dkstd |durtd ||rtd | || | d| t|||f}| | || | | |q|qdd | S) NcontractTr)get_contraction_structure%s = %scSsg|]}t|qSr)rLkeysrFfrrrrJz.CodePrinter._doprint_loops..cSsg|]}dgqSrrrvrrrrJsz0FIXME: no support for contractions in factor yetz"need assignment variable for loopszZFIXME: lhs present in rhs, this is undefined in CodePrinterr[)reget sympy.tensorrs_get_expression_indices_get_loop_opening_endingrrqrr]extend_get_statementrfrKrM_sort_optimizedNotImplementedErrorr-hasrOrl)rrVrWrsindicesZdummiesZopenloopZ closelooptextZ lhs_printedrmdZ openloop_dZ closeloop_dZtermrrr_doprint_loopss^                  zCodePrinter._doprint_loopscCsPddlm}||\}}||\}}|r|s|}||kr"td||||S)Nr) get_indicesz2lhs indices must match non-dummy rhs indices in %s)rzrrOr)rrVrWrZrindsZjunkZlindsrrrr{s    z#CodePrinter._get_expression_indicesc sddlm}|s gSi|D]}d|<q||}|D]"}t|jD]\}}z |||7<Wq#ty=Yq#wqt|fdddS)Nr)Indexedcs|Srr)xZ score_tablerrsz-CodePrinter._sort_optimized..rY)sympy.tensor.indexedrZatoms enumerater_rate_index_positionKeyErrorri) rrrVriZarraysZarrpZindrrrrs    zCodePrinter._sort_optimizedcCtd)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)rrrrrrsz CodePrinter._rate_index_positioncCr)z1Formats a codestring with the proper line ending.rr)rZ codestringrrrr~zCodePrinter._get_statementcCr)z#Formats a text string as a comment.rr)rrrrrrgrzCodePrinter._get_commentcCr)z3Declare a numeric constant at the top of a functionrr)rrnrorrrrj rz!CodePrinter._declare_number_constcCr)z~Take in a list of lines of code, and format them accordingly. This may include indenting, wrapping long lines, etc...rr)rrmrrrrkszCodePrinter._format_codecCr)zOReturns a tuple (open_lines, close_lines) containing lists of codelinesrr)rrrrrr|sz$CodePrinter._get_loop_opening_endingcCs&|jdr d|jSd|j|jfS)NZDummy_r4z%s_%d)rn startswithZ dummy_indexrrVrrr _print_Dummys  zCodePrinter._print_Dummycsdfdd|jDS)Nr[csg|]}|qSrr\)rFrr^rrrJ%sz0CodePrinter._print_CodeBlock..)rlr"rrr^r_print_CodeBlock$szCodePrinter._print_CodeBlockcCst|Sr)rRrstringrrr _print_String'szCodePrinter._print_StringcCs d|jS)Nz"%s")r)rargrrr_print_QuotedString*rzCodePrinter._print_QuotedStringcCs|t|Sr)rgrRrrrr_print_Comment-szCodePrinter._print_CommentcCs@ddlm}ddlm}ddlm}ddlm}|j}|j }t |j |rIg}g} |j D]\} } | ||| | | q+|t || } || St ||rvg} ||D]\}}||||f|||f} || }| |qUd| S|jddr||s||r|||S||}||}|d ||fS) Nr)rE) PiecewiserB) IndexedBaser[rrFrt)rarEZ$sympy.functions.elementary.piecewiserr`rCrrrGrHrKr"rfrQr]Z_traverse_matrix_indicesrlreryrrr~)rrVrErrCrrGrHZ expressionsZ conditionsecZtemprmrjZcode0lhs_coderhs_coderrr_print_Assignment0s8              zCodePrinter._print_Assignmentcs>|j}|j}djtfdd||j|gS)Nz{} {} {}c |Srr\rr^rrrY z8CodePrinter._print_AugmentedAssignment..)r]rGrHr~rPmapop)rrVrrrr^r_print_AugmentedAssignmentUs    z&CodePrinter._print_AugmentedAssignmentcs$d|jdtfdd|jfS)N%s(%s), crrr\rr^rrr_rz1CodePrinter._print_FunctionCall..)rnrlrZ function_argsrrr^r_print_FunctionCall\s zCodePrinter._print_FunctionCallcCs ||jSr)r]symbolrrrr_print_Variablebs zCodePrinter._print_VariablecCs|j\}|||Sr)r"r~r])rrVrrrr_print_StatementeszCodePrinter._print_StatementcsDt|}||jvr |jdrd}t||||jdS|S)Nr6zVThis expression includes the symbol "{}" which is a reserved keyword in this language.r7)r= _print_Symbolr<rerOrP)rrVrnmsgr@rrris   zCodePrinter._print_Symbolc sB|jjjvrNj|jj}d}t|tr|}n|D] \}}||jr%nq|durLz |fdd|jDWStyKd||jdfYSwdSt|drbt|j t rb |j |jS|jjj vrj |jjjvr | j |jjS|jrjddrd |jdtj |jfS|S)Ncsg|]}|dqS)r parenthesize)rFitemr^rrrJrxz/CodePrinter._print_Function..rr_imp_r:F)funcr)Zknown_functionsrKrRr"rTZ stringifyr>rrr]_rewriteable_functionsZrewriteZ is_Functionreryrlr_print_not_supported)rrVZ cond_funcrZcondrr^r_print_Functionvs2    $ zCodePrinter._print_FunctioncCsP|jddr|t||jdS|j|t||jdft|S)Nr9FZ precision)reryr]rZevalfrcaddrRrrrr_print_NumberSymbols zCodePrinter._print_NumberSymbolcC ||Srrrrrr_print_CatalanrzCodePrinter._print_CatalancCrrrrrrr_print_EulerGammarzCodePrinter._print_EulerGammacCrrrrrrr_print_GoldenRatiorzCodePrinter._print_GoldenRatiocCrrrrrrr_print_TribonacciConstantrz%CodePrinter._print_TribonacciConstantcCrrrrrrr _print_Exp1rzCodePrinter._print_Exp1cCrrrrrrr _print_PirzCodePrinter._print_Pic6t|djdfddt|jtdDS)N %s r0c3|] }|VqdSrrrFaPRECrrr z)CodePrinter._print_And..rYr _operatorsrlrir"rrrrr _print_And zCodePrinter._print_Andcr)Nrr1c3rrrrrrrrrz(CodePrinter._print_Or..rYrrrrr _print_OrrzCodePrinter._print_OrcHjddur |St|djdfdd|jDS)Nxorrc3rrrrrrrrrz)CodePrinter._print_Xor..rryrrrlr"rrrr _print_Xor  zCodePrinter._print_Xorcr)NZ equivalentrc3rrrrrrrrrz0CodePrinter._print_Equivalent..rrrrr_print_EquivalentrzCodePrinter._print_EquivalentcCs$t|}|jd||jd|S)Nr2r)rrrr")rrVrrrr _print_NotszCodePrinter._print_Notc st||\}}|dkrt| |}d}nd}g}g}g}jdvr)|}nt|}|D]I} | jrt| jrt| j j rt| j j rt| j dkrS| t | j| j ddq0t| jdjdkrht| jtrh| | | t | j| j q0| | q0|ptjg}fd d |D} fd d |D} |D]} | j|vrd | || j| || j<q|s|d | St|dkr|d | d| dS|d | dd | S)Nr-)oldZnoneF)Zevaluatecg|]}|qSrrrFrZprecrrrrJrxz*CodePrinter._print_Mul..crrrrrrrrJrxz(%s)*/z/(%s))rZ as_coeff_Mulrr5Zas_ordered_factorsr Z make_argsZis_commutativeZis_PowZexpZ is_RationalZ is_negativerfr baserNr"rKr ZOneindexrl) rrVrrsignrbZ pow_parenr"rZa_strZb_strrrr _print_Muls@             zCodePrinter._print_MulcCs.z|j|Wn tyYnw||Sr)rbrrTZ emptyPrinterrrrrrs   z CodePrinter._print_not_supportedr)Fr)r*r+r,rZ_default_settingsrrrqrr{rrr~rgrjrkr|rrrrrrrrrrrrZ _print_ExprZ_print_HeavisiderrrrrrrrrrrrrrZ _print_BasicZ_print_ComplexInfinityZ_print_DerivativeZ_print_ExprCondPairZ_print_GeometryEntityZ_print_InfinityZ_print_IntegralZ_print_IntervalZ_print_AccumulationBoundsZ _print_LimitZ_print_MatrixBaseZ_print_DeferredVectorZ _print_NaNZ_print_NegativeInfinityZ _print_OrderZ _print_RootOfZ_print_RootsOfZ_print_RootSumZ_print_UniformZ _print_UnitZ _print_WildZ_print_WildFunctionZ_print_Relational __classcell__rrr@rr.#s   ?O %   3  r.Nc99cK$ddlm}|||||S)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)Zsympy.printing.crlowerrq)rVrWstandardr;rrrrccode"s rcKtt|fi|dS)z0Prints C representation of the given expression.N)printrrVr;rrr print_ccodesrcKsddlm}||||S)aHConverts 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 won't 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)Zsympy.printing.fortranrrq)rVrWr;rrrrfcodes trcKr)z|Prints the Fortran representation of the given expression. See fcode for the meaning of the optional arguments. N)rrrrrr print_fcode#src++11cKr)z$ C++ equivalent of :func:`~.ccode`. r)cxx_code_printers)Zsympy.printing.cxxrrrq)rVrWrr;rrrrcxxcode*s r)Nrr)Nr)&typingrrrr functoolsrZ sympy.corerr r r r r rZsympy.core.basicrZsympy.core.compatibilityrZsympy.core.functionrZsympy.core.mulrZsympy.core.symbolrZsympy.printing.strrZsympy.printing.precedencerr Exceptionr-r.rrrrrrrrrs. $          x