a d?Z#d@dAZ$dBdCZ%dDdEZ&dFdGZ'dHdIZ(dJdKZ)dLdMZ*dNdOZ+dPdQZ,dRdSZ-dTdUZ.dVdWZ/dXdYZ0dZd[Z1d\d]Z2d^d_Z3d`daZ4dbdcZ5dddeZ6dfdgZ7dhdiZ8djdkZ9dldmZ:e:Z;ZZ?dpdqZ@drdsZAdtduZBZCS)vOctaveCodePrinterzL A printer to convert expressions to strings of Octave/Matlab code. Z_octaveZOctave&|~)andornotNautoTF)orderZ full_precZ precisionuser_functionsZhumanZallow_unknown_functionscontractinlinecsHt|tttt|_|jtt|di}|j|dS)Nr@) super__init__dictzipknown_fcns_src1known_functionsupdateknown_fcns_src2get)selfsettingsZ userfuncs __class__e/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/printing/octave.pyrD[s   zOctaveCodePrinter.__init__cCs|dS)NrP)rLprPrPrQ_rate_index_positioncsz&OctaveCodePrinter._rate_index_positioncCsd|S)Nz%s;rP)rLZ codestringrPrPrQ_get_statementgsz OctaveCodePrinter._get_statementcCs d|S)Nz% {}format)rLtextrPrPrQ _get_commentkszOctaveCodePrinter._get_commentcCs d||S)Nz{} = {};rV)rLnamevaluerPrPrQ_declare_number_constosz'OctaveCodePrinter._declare_number_constcCs ||SN) indent_code)rLlinesrPrPrQ _format_codesszOctaveCodePrinter._format_codecs |j\}fddt|DS)Nc3s$|]}tD]}||fVqqdSr])range).0jirowsrPrQ zz=OctaveCodePrinter._traverse_matrix_indices..)shapera)rLmatcolsrPrerQ_traverse_matrix_indicesws z*OctaveCodePrinter._traverse_matrix_indicescCs^g}g}|D]H}t|j|j|jd|jdg\}}}|d|||f|dq ||fS)Nzfor %s = %s:%send)map_printlabellowerupperappend)rLindicesZ open_linesZ close_linesrdvarstartstoprPrPrQ_get_loop_opening_ending}s  z*OctaveCodePrinter._get_loop_opening_endingcs|jr.|jr.tj|jr.dtj |St||\}}|dkr\t| |}d}nd}g}g}g}j dvr| }n t |}|D]} | j r"| jr"| jjr"| jjr"| jdkr|t| j| j ddnDt| jdjd kr t| jt r || |t| j| j q| jrp| tjurp| jd krR|t| j| jd krz|t| jq|| q|ptjg}fd d |D} fd d |D} |D]2} | j|vrd | || j| || j<qdd} |s|| || St|d krB|djr$dnd} || || | | dStdd|DrZdnd} || || | d | || SdS)Nz%sir-)oldnoneF)evaluatermcsg|]}|qSrP parenthesizerbxprecrLrPrQ rhz0OctaveCodePrinter._print_Mul..csg|]}|qSrPrrrrPrQrrhz(%s)cSsF|d}tdt|D]*}||djr,dnd}||||}q|S)Nrrm*.*)ralen is_number)aa_strrrdZmulsymrPrPrQmultjoins z.OctaveCodePrinter._print_Mul..multjoin/./css|] }|jVqdSr]r)rbZbirPrPrQrgrhz/OctaveCodePrinter._print_Mul..)rZ is_imaginaryrZ ImaginaryUnitZ is_Integerrpr Z as_coeff_Mulrr?Zas_ordered_factorsrZ make_argsis_commutativeZis_Powr!Z is_RationalZ is_negativertrbaserargs isinstanceInfinityrSrqOneindexall)rLexprcer&rbZ pow_parenritemrZb_strrZdivsymrPrrQ _print_Mulsb        $     $  zOctaveCodePrinter._print_MulcCs,||j}||j}|j}d|||S)Nz{} {} {})rplhsrhsZrel_oprW)rLrlhs_coderhs_codeoprPrPrQ_print_Relationals  z#OctaveCodePrinter._print_RelationalcCstdd|jDrdnd}t|}|jtjkr@d||jS|jr|jtj kr||jj r`dnd}d|d||jS|jtj kr|jj rdnd}d|d | |j|Sd | |j||| |j|fS) Ncss|] }|jVqdSr]rrrPrPrQrgrhz/OctaveCodePrinter._print_Pow..^z.^zsqrt(%s)rr1%sz%s%s%s) rrr r!rHalfrprrrrr)rLrZ powsymbolPRECsymrPrPrQ _print_Pows  zOctaveCodePrinter._print_PowcCs(t|}d||j|||j|fS)Nz%s^%s)r rrr!rLrrrPrPrQ _print_MatPows zOctaveCodePrinter._print_MatPowcCs(t|}d||j|||j|fS)Nz%s \ %s)r rZmatrixZvectorrrPrPrQ_print_MatrixSolves z$OctaveCodePrinter._print_MatrixSolvecCsdS)NpirPrLrrPrPrQ _print_PiszOctaveCodePrinter._print_PicCsdS)NZ1irPrrPrPrQ_print_ImaginaryUnitsz&OctaveCodePrinter._print_ImaginaryUnitcCsdS)Nzexp(1)rPrrPrPrQ _print_Exp1szOctaveCodePrinter._print_Exp1cCsdS)Nz (1+sqrt(5))/2rPrrPrPrQ_print_GoldenRatiosz$OctaveCodePrinter._print_GoldenRatiocCsddlm}ddlm}ddlm}|j}|j}|jdst |j|rg}g}|j D]"\} } | ||| | | qT|t ||} | | S|jdr||s||r|||S| |} | |} |d| | fSdS)Nr) Assignment) Piecewise) IndexedBaserBrAz%s = %s)Zsympy.codegen.astrZ$sympy.functions.elementary.piecewiserZsympy.tensor.indexedrrr _settingsrrrtrFrpZhasZ_doprint_loopsrU)rLrrrrrrZ expressionsZ conditionsrrtemprrrPrPrQ_print_Assignment s(        z#OctaveCodePrinter._print_AssignmentcCsdS)NinfrPrrPrPrQ_print_Infinity&sz!OctaveCodePrinter._print_InfinitycCsdS)Nz-infrPrrPrPrQ_print_NegativeInfinity*sz)OctaveCodePrinter._print_NegativeInfinitycCsdS)NNaNrPrrPrPrQ _print_NaN.szOctaveCodePrinter._print_NaNcs ddfdd|DdS)N{, c3s|]}|VqdSr]rprbrrLrPrQrg3rhz0OctaveCodePrinter._print_list..}joinrrPrrQ _print_list2szOctaveCodePrinter._print_listcCsdS)NtruerPrrPrPrQ_print_BooleanTrue9sz$OctaveCodePrinter._print_BooleanTruecCsdS)NfalserPrrPrPrQ_print_BooleanFalse=sz%OctaveCodePrinter._print_BooleanFalsecCs t|Sr])strrrrrPrPrQ _print_boolAszOctaveCodePrinter._print_boolcsrjjfdkrdStjjvr0djjfSjjfdkrNdSddfddtjDS) N)rrz[]z zeros(%s, %s))rmrmz[%s]z; c3s2|]*}dfdd|ddfDVqdS) csg|]}|qSrPrrrrPrQrRrhzAOctaveCodePrinter._print_MatrixBase...Nr)rbrArLrPrQrgRsz6OctaveCodePrinter._print_MatrixBase..)rfrkrZZerorirprra)rLrrPrrQ_print_MatrixBaseIs z#OctaveCodePrinter._print_MatrixBasecCsxddlm}|}|dd|Dg}|dd|Dg}|dd|Dg}d|||||||j|jfS)Nr)MatrixcSsg|]}|ddqS)rrmrPrbkrPrPrQrZrhz.cSsg|]}|ddqS)rmrPrrPrPrQr[rhcSsg|] }|dqS)rPrrPrPrQr\rhzsparse(%s, %s, %s, %s, %s))Zsympy.matricesrZcol_listrprfrk)rLrrLIJZAIJrPrPrQ_print_SparseRepMatrixVs z(OctaveCodePrinter._print_SparseRepMatrixcCs.|j|jtdddd|jd|jdfS)NZAtomT)strictz(%s, %s)rm)rparentr rdrcrrPrPrQ_print_MatrixElementasz&OctaveCodePrinter._print_MatrixElementcsLfdd}|jd||j|jjdd||j|jjddS)Ncs|dd}|d}|d}|}||kr2dn|}|dkrr|dkrX||krXdS||krd|S|d|Snd|||fSdS)Nrrmrrn:)rpr)rZlimlhstepZlstrZhstrrrPrQstrslicegs  z6OctaveCodePrinter._print_MatrixSlice..strslice(rrrm))rprZrowsliceriZcolslice)rLrrrPrrQ_print_MatrixSlicefs z$OctaveCodePrinter._print_MatrixSlicecs0fdd|jD}d|jjd|fS)Ncsg|]}|qSrPr)rbrdrrPrQr|rhz4OctaveCodePrinter._print_Indexed..z%s(%s)r)rurprrqr)rLrZindsrPrrQ_print_Indexed{sz OctaveCodePrinter._print_IndexedcCs ||jSr])rprqrrPrPrQ _print_IdxszOctaveCodePrinter._print_Idxcs&tddtfdd|jDS)Nrzdouble(%s == %s)c3s|]}|VqdSr]rrrrPrQrgsz:OctaveCodePrinter._print_KroneckerDelta..)r tuplerrrPrrQ_print_KroneckerDeltasz'OctaveCodePrinter._print_KroneckerDeltacsdfddjDS)Nrcsg|]}|tqSrP)rr )rbr0rrLrPrQrsz.)rrrrPrrQ_print_HadamardProductsz(OctaveCodePrinter._print_HadamardProductcCs*t|}d||j|||j|gS)Nz.**)r rrrr!rrPrPrQ_print_HadamardPowers   z&OctaveCodePrinter._print_HadamardPowercsP|j}t|dkr,|d|dkr,|dg}dfdd|D}d|dS) Nrrrmrc3s|]}|VqdSr]r)rbnrrPrQrgrhz4OctaveCodePrinter._print_Identity..zeye(r)rirr)rLrrisrPrrQ_print_Identitys  z!OctaveCodePrinter._print_IdentitycCs$d||jd||jdS)Nz (gammainc({1}, {0}).*gamma({0}))rrmrWrprrrPrPrQ_print_lowergammasz#OctaveCodePrinter._print_lowergammacCs$d||jd||jdS)Nz)(gammainc({1}, {0}, 'upper').*gamma({0}))rrmrrrPrPrQ_print_uppergammasz#OctaveCodePrinter._print_uppergammacCsd||jdtjS)Nzsinc(%s)r)rprrPirrPrPrQ _print_sincszOctaveCodePrinter._print_sinccCsd||j||jfS)Nzbesselh(%s, 1, %s)rpr?argumentrrPrPrQ_print_hankel1s  z OctaveCodePrinter._print_hankel1cCsd||j||jfS)Nzbesselh(%s, 2, %s)rrrPrPrQ_print_hankel2s  z OctaveCodePrinter._print_hankel2cCsDddlm}m}|j}|tjd|||jtj|}||S)Nr)sqrtrr) sympy.functionsrrrrrr?rrp)rLrrrrexpr2rPrPrQ _print_jns$zOctaveCodePrinter._print_jncCsDddlm}m}|j}|tjd|||jtj|}||S)Nr)rrr) rrrrrrr?rrp)rLrrrrrrPrPrQ _print_yns$zOctaveCodePrinter._print_yncCsd||jdS)Nz airy(0, %s)rrprrrPrPrQ _print_airyaiszOctaveCodePrinter._print_airyaicCsd||jdS)Nz airy(1, %s)rrrrPrPrQ_print_airyaiprimesz$OctaveCodePrinter._print_airyaiprimecCsd||jdS)Nz airy(2, %s)rrrrPrPrQ _print_airybiszOctaveCodePrinter._print_airybicCsd||jdS)Nz airy(3, %s)rrrrPrPrQ_print_airybiprimesz$OctaveCodePrinter._print_airybiprimecCs*|j\}}|dkr||Sd||S)Nrmz expint(%s))r_print_not_supportedrp)rLrmurrPrPrQ _print_expints  zOctaveCodePrinter._print_expintcsDt|jdksJdjj|jjdfddt|jDdS)Nrz{name}({args})rcsg|]}|qSrPrrrrPrQrrhz?OctaveCodePrinter._one_or_two_reversed_args..)rZr)rrrWrHrO__name__rreversedrrPrrQ_one_or_two_reversed_argss  z+OctaveCodePrinter._one_or_two_reversed_argsc Cs<dj|j|jj||jd||j|jdddS)Nz{name}({arg1}, {arg2})rrm)rZZarg1Zarg2)rWrHrOrrprfuncrrPrPrQ_nested_binary_math_funcs  z*OctaveCodePrinter._nested_binary_math_funcc s,|jdjdkrtdg}jdr~fdd|jddD}d|jdj}d||d t|}d |d St|jD]\}\}}|d kr| d |n:|t|jd kr|dkr| dn| d||} | | |t|jd kr| dqd|SdS)Nr~TzAll 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.rBcs(g|] \}}d||qS)z({0}).*({1}) + (~({0})).*()rWrp)rbrrrrPrQrsz6OctaveCodePrinter._print_Piecewise..rz ... rrrzif (%s)rmelsez elseif (%s)rn ) rZcond ValueErrorrrprrr enumeratert) rLrr_ZecpairsZelastpwrdrrZcode0rPrrQ_print_Piecewises*        z"OctaveCodePrinter._print_PiecewisecCs0t|jdkr"d||jdS||SdS)Nrmzzeta(%s)r)rrrprrrPrPrQ _print_zetaszOctaveCodePrinter._print_zetac st|tr$||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }t|D]J\}} | d vr|| qr|||8}|d ||| f|||7}qr|S) z0Accepts a string of code or a list of code linesTr{z )z ^function z^if ^elseif ^else$z^for )z^end$rrcSsg|]}|dqS)z )lstrip)rblinerPrPrQr*rhz1OctaveCodePrinter.indent_code..cs&g|]ttfddDqS)c3s|]}t|VqdSr]r rbr5rrPrQrg,rh;OctaveCodePrinter.indent_code...intanyrb) inc_regexrrQr,scs&g|]ttfddDqS)c3s|]}t|VqdSr]r rrrPrQrg.rhrrr) dec_regexrrQr.sr)r{rz%s%s)rrr^ splitlinesrrrt) rLcodeZ code_linestabZincreaseZdecreaseprettylevelrrrP)r rrQr^s.      zOctaveCodePrinter.indent_code)Dr __module__ __qualname____doc__Z printmethodlanguage _operatorsZ_default_settingsrDrTrUrYr\r`rlryrrrrrrrrrrrrrrZ _print_tupleZ _print_TupleZ _print_Listrrrrrrrrrrrrrrrrrrrrrrrrrr Z_print_DiracDeltaZ_print_LambertWr Z _print_MaxZ _print_Minrrr^ __classcell__rPrPrNrQr6?s J  %r6NcKst|||S)aConverts `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 >>> 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 >>> 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));' )r6Zdoprint)rZ assign_torMrPrPrQ octave_code=s r,cKstt|fi|dS)zPrints the Octave (or Matlab) representation of the given expression. See `octave_code` for the meaning of the optional arguments. N)printr,)rrMrPrPrQprint_octave_codesr.)N)r(typingrrZtDictZ sympy.corerrrrZsympy.core.mulrZsympy.printing.codeprinterr Zsympy.printing.precedencer r r5r rGrJr6r,r.rPrPrPrQsP