U Zʹj]7@sdZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z dd d d d d ddddddddddddddddddd d!d"d#d$Zd%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8gZGd9d:d:eZd@dd?Zd;S)Az R code printer The RCodePrinter converts single SymPy expressions into single R expressions, using the functions defined in math.h where possible. ) annotations)Any) equal_valued) CodePrinter) precedence PRECEDENCE)Rangeabssincostanasinacosatanatan2explogerfsinhcoshtanhasinhacoshatanhfloorceilingsignmaxmin factorialgammadigammatrigammabetasqrt)ZAbsr r r r rrrrrrrrrrrrrrrZMaxZMinrr r!r"r#r$ifelserepeatwhilefunctionforinnextbreakTRUEFALSEZNULLInfNaNZNAZ NA_integer_ZNA_real_Z NA_complex_Z NA_character_Zvolatilecs(eZdZUdZdZdZeejfdide dZde d<d d d d Z iZ d e d<ifddZ ddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Z fd7d8Z!d9d:Z"d;d<Z#d=d>Z$d?d@Z%Z&S)A RCodePrinterz;A printer to convert SymPy expressions to strings of R codeZ_rcodeRT) precisionuser_functionscontract dereferencezdict[str, Any]_default_settings&|!)andornotzdict[str, str] _relationalscCsNt||tt|_|di}|j|t|dg|_tt|_dS)Nr6r8) r__init__dictknown_functionsgetupdateset _dereferencereserved_words)selfsettingsZ userfuncsrKS/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/printing/rcode.pyrAas     zRCodePrinter.__init__cCs|dS)NrK)rIprKrKrL_rate_index_positionisz!RCodePrinter._rate_index_positioncCsd|S)Nz%s;rK)rIZ codestringrKrKrL_get_statementlszRCodePrinter._get_statementcCs d|S)Nz// {}format)rItextrKrKrL _get_commentoszRCodePrinter._get_commentcCs d||S)Nz{} = {};rQ)rInamevaluerKrKrL_declare_number_constrsz"RCodePrinter._declare_number_constcCs ||SN) indent_code)rIlinesrKrKrL _format_codeuszRCodePrinter._format_codecs |j\}fddt|DS)Nc3s$|]}tD]}||fVqqdSrX)range).0ijcolsrKrL zs z8RCodePrinter._traverse_matrix_indices..)shaper\)rIZmatrowsrKr`rL_traverse_matrix_indicesxs z%RCodePrinter._traverse_matrix_indicesc Cs^g}g}d}|D]D}||||j||jd||jdd|dq||fS)zPReturns a tuple (open_lines, close_lines) containing lists of codelines z#for (%(var)s in %(start)s:%(end)s){)varstartend})append_printlabellowerupper)rIindicesZ open_linesZ close_linesZ loopstartr^rKrKrL_get_loop_opening_ending|s   z%RCodePrinter._get_loop_opening_endingcCszd|jkr||St|}t|jdr:d||j|St|jdrVd||jSd||j|||j|fSdS)NPowz1.0/%sg?zsqrt(%s)z%s^%s)rCZ_print_Functionrrr parenthesizebaserl)rIexprZPRECrKrKrL _print_Pows     zRCodePrinter._print_PowcCs"t|jt|j}}d||fS)Nz %d.0/%d.0)intrNq)rIrvrNryrKrKrL_print_RationalszRCodePrinter._print_Rationalcs0fdd|jD}d|jjd|fS)Ncsg|]}|qSrK)rl)r]r^rIrKrL sz/RCodePrinter._print_Indexed..z%s[%s]z, )rprlrurmjoin)rIrvZindsrKr{rL_print_IndexedszRCodePrinter._print_IndexedcCs ||jSrX)rlrmrIrvrKrKrL _print_IdxszRCodePrinter._print_IdxcCsdS)Nzexp(1)rKrrKrKrL _print_Exp1szRCodePrinter._print_Exp1cCsdS)NpirKrrKrKrL _print_PiszRCodePrinter._print_PicCsdS)Nr0rKrrKrKrL_print_InfinityszRCodePrinter._print_InfinitycCsdS)Nz-InfrKrrKrKrL_print_NegativeInfinitysz$RCodePrinter._print_NegativeInfinitycCsddlm}ddlm}ddlm}|j}|j}t||rg}| |D]6\}} |||| f||| f} | | } | | qHd |S|j dr||s||r|||S| |} | |} |d| | fSdS)Nr) Assignment) MatrixSymbol) IndexedBase r7z%s = %s)Zsympy.codegen.astrZ"sympy.matrices.expressions.matexprrZsympy.tensor.indexedrlhsrhs isinstancererlrkr}Z _settingshasZ_doprint_loopsrP)rIrvrrrrrrZr^r_tempZcode0lhs_coderhs_coderKrKrL_print_Assignments&          zRCodePrinter._print_AssignmentcCs|jdjdkr(d||jdj}n(d||jdj||jdjf}|}t|jddD](\}}d||||f|d}qf|S)NrsTz%szifelse(%s,%s,NA)z ifelse(%s,%s,))argsZcondrlrvreversed)rIrv last_linecodeecrKrKrL_print_Piecewises("zRCodePrinter._print_PiecewisecCsddlm}|||S)Nr) Piecewise)Zsympy.functionsrrlZrewrite)rIrvrrKrKrL _print_ITEs zRCodePrinter._print_ITEcCs2d|j|jtddd|j|j|jjdS)Nz{}[{}]ZAtomT)strictrf)rRrtparentrr_r^rcrrKrKrL_print_MatrixElements z!RCodePrinter._print_MatrixElementcs(t|}||jkr d|S|SdS)Nz(*{}))super _print_SymbolrGrR)rIrvrU __class__rKrLrs   zRCodePrinter._print_SymbolcCs,||j}||j}|j}d|||S)Nz{} {} {})rlrrZrel_oprR)rIrvrroprKrKrL_print_Relationals  zRCodePrinter._print_RelationalcCs,||j}|j}||j}d|||S)Nz {} {} {};)rlrrrrR)rIrvrrrrKrKrL_print_AugmentedAssignments  z'RCodePrinter._print_AugmentedAssignmentcCsT||j}t|jtr(|jj\}}}ntd||j}dj|||d||dS)Nz*Only iterable currently supported is RangezCfor({target} in seq(from={start}, to={stop}, by={step}){{ {body} }}rf)targetrhstopstepbody) rlrriterablerrNotImplementedErrorrrR)rIrvrrhrrrrKrKrL _print_Fors   zRCodePrinter._print_Forc st|tr$||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }t|D]J\}} | d kr|| qr|||8}|d ||| f|||7}qr|S) z0Accepts a string of code or a list of code linesTz ){(z{ z( )rjrcSsg|]}|dqS)z )lstripr]linerKrKrLr|sz,RCodePrinter.indent_code..cs g|]}ttt|jqSrK)rxanymapendswithr) inc_tokenrKrLr|scs g|]}ttt|jqSrK)rxrr startswithr) dec_tokenrKrLr|sr)rrz%s%s)rstrrY splitlinesr} enumeraterk) rIrZ code_linestabZincreaseZdecreaseprettylevelnrrK)rrrLrYs*     zRCodePrinter.indent_code)'__name__ __module__ __qualname____doc__Z printmethodlanguagerBrr9rF__annotations__ _operatorsr@rArOrPrTrWr[rerqrwrzr~rrrrrrrrrrrrrrY __classcell__rKrKrrLr2NsN    '   r2NcKst|||S)aConverts an expr to a string of r 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 R string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, rfunction_string)] or [(argument_test, rfunction_formater)]. 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]. Examples ======== >>> from sympy import rcode, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> rcode((2*tau)**Rational(7, 2)) '8*sqrt(2)*tau^(7.0/2.0)' >>> rcode(sin(x), assign_to="s") 's = sin(x);' 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') >>> rcode(func(Abs(x) + ceiling(x)), user_functions=custom_functions) 'f(fabs(x) + CEIL(x))' or if the R-function takes a subset of the original arguments: >>> rcode(2**x + 3**x, 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(rcode(expr, assign_to=tau)) tau = ifelse(x > 0,x + 1,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])) >>> rcode(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(rcode(mat, A)) A[0] = x^2; A[1] = ifelse(x > 0,x + 1,x); A[2] = sin(x); )r2Zdoprint)rvZ assign_torJrKrKrLrcode%skrcKstt|f|dS)z0Prints R representation of the given expression.N)printr)rvrJrKrKrL print_rcodesr)N)r __future__rtypingrZsympy.core.numbersrZsympy.printing.codeprinterrZsympy.printing.precedencerrZsympy.sets.fancysetsrrCrHr2rrrKrKrKrLsx     #X n