~9\c0@ sdZddlmZmZddlmZddlmZmZm Z m Z ddl m Z m Z ddlmZddlmZddlmZmZdd lmZd d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9g0Zid:d;6d<d=6d>d?6d@dA6dBdC6dDdE6dFdG6dHdI6dJdK6dLdM6dNdO6dPdQ6dRdS6dTdU6dVdW6dXdY6dZd[6d\d]6d^d_6d`da6dbdc6ddde6ZdfefdgYZedhZdiZdjS(ksi Octave (and Matlab) code printer The `OctaveCodePrinter` converts SymPy expressions into Octave expressions. It uses a subset of the Octave language for Matlab compatibility. A complete code generator, which uses `octave_code` extensively, can be found in `sympy.utilities.codegen`. The `codegen` module can be used to generate complete source code files. i(tprint_functiontdivision(t Assignment(tMultPowtStRational(t string_typestrange(t _keep_coeff(t CodePrinter(t precedencet PRECEDENCE(tsearchtsintcosttantcottsectcsctasintacostacottatantatan2tasectacsctsinhtcoshttanhtcothtcschtsechtasinhtacoshtatanhtacothtasechtacschterfcterfiterfterfinvterfcinvtbesselitbesseljtbesselktbesselyt bernoullitbetateulertexpt factorialtfloortfresnelctfresnelstgammatharmonictlogtpolylogtsigntzetatabstAbstangletargtceiltceilingt chebyshevUt chebyshevut chebyshevTt chebyshevttcoshinttChitcosinttCitconjt conjugatetdiract DiracDeltat heavisidet Heavisidetimagtimt laguerreLtlaguerretlambertwtLambertWtloginttlitgammalntloggammatmaxtMaxtmintMintpsit polygammatrealtret pochhammertRisingFactorialtsinhinttShitsininttSitOctaveCodePrintercB sfeZdZdZdZidd6dd6dd6ZidCd 6d d 6d d 6id6ed6ed6ed6ed6Z idZ dZ dZ dZ dZdZdZdZdZdZdZdZdZd Zd!Zd"Zd#Zd$Zd%Zd&ZeZeZd'Z d(Z!d)Z"d*Z#d+Z$e#Z%Z&Z'Z(Z)e$Z*Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;d<Z<d=Z=d>Z>e>Z?Z@d?ZAeAZBZCd@ZDdAZEdBZFRS(DsL A printer to convert expressions to strings of Octave/Matlab code. t_octavetOctavet&tandt|tort~tnottordertautot full_precit precisiontuser_functionsthumantallow_unknown_functionstcontracttinlinecC sjtt|j|tttt|_|jjtt|j di}|jj|dS(NRw( tsuperRjt__init__tdicttziptknown_fcns_src1tknown_functionstupdatetknown_fcns_src2tget(tselftsettingst userfuncs((s4lib/python2.7/site-packages/sympy/printing/octave.pyR}Zs cC s|dS(Ni((Rtp((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_rate_index_positionbscC sd|S(Ns%s;((Rt codestring((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_get_statementfscC s dj|S(Ns% {0}(tformat(Rttext((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _get_commentjscC sdj||S(Ns {0} = {1};(R(Rtnametvalue((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_declare_number_constnscC s |j|S(N(t indent_code(Rtlines((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _format_codersc s)|j\}fdt|DS(Nc3 s.|]$}tD]}||fVqqdS(N(R(t.0tjti(trows(s4lib/python2.7/site-packages/sympy/printing/octave.pys ys(tshapeR(Rtmattcols((Rs4lib/python2.7/site-packages/sympy/printing/octave.pyt_traverse_matrix_indicesvscC sg}g}xj|D]b}t|j|j|jd|jdg\}}}|jd|||f|jdqW||fS(Nisfor %s = %s:%stend(tmapt_printtlabeltlowertuppertappend(Rtindicest open_linest close_linesRtvartstarttstop((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_get_loop_opening_ending|s  ,cC sr|jr;|jr;tj|jr;d|jtj |St|}|j\}}|dkr~t| |}d}nd}g}g}g}|j dkr|j } nt j |} xC| D];} | j r| jr| jjr| jjr| jdkr/|jt| j| j dtqt| jdjd krmt| jt rm|j| n|jt| j| j q| jr| tjk r| jd kr|jt| jn| jd kr|jt| jqq|j| qW|ptjg}g|D]} |j| |^q"} g|D]} |j| |^qG} xJ|D]B} | j|krld | |j| j| |j| j(st}(tjoin(RR((Rs4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_list'scC sdS(Nttrue((RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_BooleanTrue-scC sdS(Ntfalse((RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_BooleanFalse1scC st|jS(N(tstrR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_bool5sc sjjfdkrdSjdks:jdkrNdjjfSjjfd krwjd SddjfdtjDS( Nis[]s zeros(%s, %s)is[%s]s; c3 sJ|]@}djg|ddfD]}j|^q&VqdS(t N(RR(RRR(tAR(s4lib/python2.7/site-packages/sympy/printing/octave.pys Fs(ii(ii(ii(RRRRR(RR((RRs4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_MatrixBase=scC sddlm}|j}|g|D]}|dd^q&g}|g|D]}|dd^qPg}|g|D]}|d^qzg}d|j||j||j||j|jfS(Ni(tMatrixiiissparse(%s, %s, %s, %s, %s)(tsympy.matricesRtcol_listRRR(RRRtLtktItJtAIJ((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_SparseMatrixJs **&cC s9|j|jtddtd|jd|jdfS(NtAtomtstricts(%s, %s)i(RtparentR tTrueRR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_MatrixElementcsc s_fd}j|jd||j|jjdd||j|jjddS(Nc s|dd}|d}|d}j|}||krCdn j|}|dkr|dkrz||krzdS||kr|S|d|Sndj|j||fSdS(NiiiRt:(RR(Rtlimtlthtsteptlstrthstr(R(s4lib/python2.7/site-packages/sympy/printing/octave.pytstrsliceis  !  t(is, it)(RRtrowsliceRtcolslice(RRR((Rs4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_MatrixSlicehscC sKg|jD]}|j|^q }d|j|jjdj|fS(Ns%s(%s)s, (RRRRR(RRRtinds((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_Indexed}s%cC s|j|jS(N(RR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_Idxsc s.tddtfd|jDS(NRsdouble(%s == %s)c3 s!|]}j|VqdS(N(R(RR(RR(s4lib/python2.7/site-packages/sympy/printing/octave.pys s(R ttupleR(RR((RRs4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_KroneckerDeltas c sj|j}t|dkr?|d|dkr?|dg}ndjfd|D}d|dS(Niiis, c3 s|]}j|VqdS(N(R(Rtn(R(s4lib/python2.7/site-packages/sympy/printing/octave.pys sseye(R(RRR(RRRts((Rs4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_Identitys  &cC s0dj|j|jd|j|jdS(Ns (gammainc({1}, {0}).*gamma({0}))ii(RRR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_lowergammascC s0dj|j|jd|j|jdS(Ns)(gammainc({1}, {0}, 'upper').*gamma({0}))ii(RRR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_uppergammascC sd|j|jdtjS(Nssinc(%s)i(RRRtPi(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_sincscC s&d|j|j|j|jfS(Nsbesselh(%s, 1, %s)(RRstargument(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_hankel1scC s&d|j|j|j|jfS(Nsbesselh(%s, 2, %s)(RRsR/(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_hankel2scC sZddlm}m}|j}|tjd|||jtj|}|j|S(Ni(tsqrtR-i( tsympy.functionsR2R-R/RR-RsRR(RRR2R-Rtexpr2((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_jns .cC sZddlm}m}|j}|tjd|||jtj|}|j|S(Ni(R2R/i( R3R2R/R/RR-RsRR(RRR2R/RR4((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_yns .cC sd|j|jdS(Ns airy(0, %s)i(RR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_airyaiscC sd|j|jdS(Ns airy(1, %s)i(RR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_airyaiprimescC sd|j|jdS(Ns airy(2, %s)i(RR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_airybiscC sd|j|jdS(Ns airy(3, %s)i(RR(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_airybiprimescC s9|j\}}|dkr(|j|Sd|j|S(Nis expint(%s)(Rt_print_not_supportedR(RRtmuR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_expints  c C slt|jdkstdjd|j|jjddjgt|jD]}|j |^qMS(Nis{name}({args})RRs, ( RRtAssertionErrorRRt __class__t__name__RtreversedR(RRR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_one_or_two_reversed_argss c C sRdjd|j|jjd|j|jdd|j|j|jdS(Ns{name}({arg1}, {arg2})Rtarg1itarg2i(RRR?R@RRtfunc(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_nested_binary_math_funcs c C s|jdjtkr%tdng}|jdrg|jd D]0\}}dj|j||j|^qF}d|j|jdj}dj||dt |}d|dSxt |jD]\}\}}|d kr|j d |j|nO|t |jd krF|tkrF|j d n|j d |j||j|} |j | |t |jd kr|j dqqWdj|SdS(NisAll 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.R{s({0}).*({1}) + (~({0})).*(s%ss ... RRisif (%s)itelses elseif (%s)Rs ( RtcondRt ValueErrorRRRRRRt enumerateR( RRRRRtecpairstelasttpwRtcode0((s4lib/python2.7/site-packages/sympy/printing/octave.pyt_print_Piecewises( A! " % cC s>t|jdkr-d|j|jdS|j|SdS(Niszeta(%s)i(RRRR;(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt _print_zetasc C syt|tr4|j|jt}dj|Sd}d }d}g|D]}|jd ^qM}g|D]4}ttg|D]}t ||^q^qo}g|D]4}ttg|D]}t ||^q^q} g} d } x|t |D]n\} }|dks'|d kr:| j |qn| | | 8} | j d || |f| || 7} qW| S(s0Accepts a string of code or a list of code linesRs s ^function s^if s^elseif s^else$s^for s^end$s is s%s%s(s ^function s^if s^elseif s^else$s^for (s^end$s^elseif s^else$( RRRt splitlinesRRtlstriptinttanyR RJR( Rtcodet code_linesttabt inc_regext dec_regextlineRctincreasetdecreasetprettytlevelR(((s4lib/python2.7/site-packages/sympy/printing/octave.pyRs* ">> N(GR@t __module__t__doc__t printmethodtlanguaget _operatorstNoneRRt_default_settingsR}RRRRRRRRRRRRRRRRRRRt _print_tuplet _print_TupleRRRRRt _print_Matrixt_print_DenseMatrixt_print_MutableDenseMatrixt_print_ImmutableMatrixt_print_ImmutableDenseMatrixt_print_MutableSparseMatrixt_print_ImmutableSparseMatrixRR"R$R%R'R*R+R,R.R0R1R5R6R7R8R9R:R=RBt_print_DiracDeltat_print_LambertWRFt _print_Maxt _print_MinRORPR(((s4lib/python2.7/site-packages/sympy/printing/octave.pyRj>s          K                                       % cK st|j||S(sConverts `expr` to a string of Octave (or Matlab) code. The string uses a subset of the Octave language for Matlab compatibility. 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 can be helpful for expressions that generate multi-line statements. precision : integer, optional The precision for numbers such as pi [default=16]. 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]. inline: bool, optional If True, we try to create single-statement code instead of multiple statements. [default=True]. Examples ======== >>> from sympy import octave_code, symbols, sin, pi >>> x = symbols('x') >>> octave_code(sin(x).series(x).removeO()) 'x.^5/120 - x.^3/6 + x' >>> from sympy import Rational, ceiling, Abs >>> x, y, tau = symbols("x, y, tau") >>> octave_code((2*tau)**Rational(7, 2)) '8*sqrt(2)*tau.^(7/2)' Note that element-wise (Hadamard) operations are used by default between symbols. This is because its very common in Octave to write "vectorized" code. It is harmless if the values are scalars. >>> octave_code(sin(pi*x*y), assign_to="s") 's = sin(pi*x.*y);' If you need a matrix product "*" or matrix power "^", you can specify the symbol as a ``MatrixSymbol``. >>> from sympy import Symbol, MatrixSymbol >>> n = Symbol('n', integer=True, positive=True) >>> A = MatrixSymbol('A', n, n) >>> octave_code(3*pi*A**3) '(3*pi)*A^3' This class uses several rules to decide which symbol to use a product. Pure numbers use "*", Symbols use ".*" and MatrixSymbols use "*". A HadamardProduct can be used to specify componentwise multiplication ".*" of two MatrixSymbols. There is currently there is no easy way to specify scalar symbols, so sometimes the code might have some minor cosmetic issues. For example, suppose x and y are scalars and A is a Matrix, then while a human programmer might write "(x^2*y)*A^3", we generate: >>> octave_code(x**2*y*A**3) '(x.^2.*y)*A^3' Matrices are supported using Octave inline notation. When using ``assign_to`` with matrices, the name can be specified either as a string or as a ``MatrixSymbol``. The dimensions must align in the latter case. >>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([[x**2, sin(x), ceiling(x)]]) >>> octave_code(mat, assign_to='A') 'A = [x.^2 sin(x) ceil(x)];' ``Piecewise`` expressions are implemented with logical masking by default. Alternatively, you can pass "inline=False" to use if-else conditionals. 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 >>> pw = Piecewise((x + 1, x > 0), (x, True)) >>> octave_code(pw, assign_to=tau) 'tau = ((x > 0).*(x + 1) + (~(x > 0)).*(x));' Note that any expression that can be generated normally can also exist inside a Matrix: >>> mat = Matrix([[x**2, pw, sin(x)]]) >>> octave_code(mat, assign_to='A') 'A = [x.^2 ((x > 0).*(x + 1) + (~(x > 0)).*(x)) 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)]. This can be used to call a custom Octave function. >>> from sympy import Function >>> f = Function('f') >>> g = Function('g') >>> custom_functions = { ... "f": "existing_octave_fcn", ... "g": [(lambda x: x.is_Matrix, "my_mat_fcn"), ... (lambda x: not x.is_Matrix, "my_fcn")] ... } >>> mat = Matrix([[1, x]]) >>> octave_code(f(x) + g(x) + g(mat), user_functions=custom_functions) 'existing_octave_fcn(x) + my_fcn(x) + my_mat_fcn([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, ccode >>> 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])) >>> octave_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy(i) = (y(i + 1) - y(i))./(t(i + 1) - t(i));' (Rjtdoprint(Rt assign_toR((s4lib/python2.7/site-packages/sympy/printing/octave.pyt octave_code6scK stt||dS(sPrints the Octave (or Matlab) representation of the given expression. See `octave_code` for the meaning of the optional arguments. N(tprintRu(RR((s4lib/python2.7/site-packages/sympy/printing/octave.pytprint_octave_codesN(R`t __future__RRtsympy.codegen.astRt sympy.coreRRRRtsympy.core.compatibilityRRtsympy.core.mulR tsympy.printing.codeprinterR tsympy.printing.precedenceR R RcR RRRjRdRuRw(((s4lib/python2.7/site-packages/sympy/printing/octave.pyt sX"