o ݹi}c @s dZddlmZddlmZddlmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZdd lmZgd Zid d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4ZGd5d6d6eZdZ&d?d@Z'dAdBZ(dCdDZ)dEdFZ*dGdHZ+dIdJZ,dKdLZ-dMdNZ.dOdPZ/dQdRZ0dSdTZ1dUdVZ2dWdXZ3dYdZZ4d[d\Z5d]d^Z6d_d`Z7dadbZ8dcddZ9dedfZ:dgdhZ;didjZdkdlZ?e?Z@ZAdmdnZBdodpZCdqdrZDZES)sOctaveCodePrinterzL A printer to convert expressions to strings of Octave/Matlab code. _octaveOctave&|~)andornotT) precisionuser_functionscontractinlinezdict[str, Any]_default_settingscsHt|tttt|_|jtt|di}|j|dS)Nr{) super__init__dictzipknown_fcns_src1known_functionsupdateknown_fcns_src2get)selfsettings userfuncs __class__R/home/ubuntu/veenaModal/venv/lib/python3.10/site-packages/sympy/printing/octave.pyrYs  zOctaveCodePrinter.__init__cCs|dS)Nr)rprrr_rate_index_positionaz&OctaveCodePrinter._rate_index_positioncCsd|S)Nz%s;r)r codestringrrr_get_statementerz OctaveCodePrinter._get_statementcCs d|S)Nz% {}format)rtextrrr _get_commenti zOctaveCodePrinter._get_commentcCs d||S)Nz{} = {};r)rnamevaluerrr_declare_number_constm z'OctaveCodePrinter._declare_number_constcCs ||SN) indent_code)rlinesrrr _format_codeqrzOctaveCodePrinter._format_codecs |j\}fddt|DS)Nc3s&|]}tD]}||fVqqdSr)range).0jirowsrr xs$z=OctaveCodePrinter._traverse_matrix_indices..)shaper)rmatcolsrrr_traverse_matrix_indicesus z*OctaveCodePrinter._traverse_matrix_indicescCs^g}g}|D]$}t|j|j|jd|jdg\}}}|d|||f|dq||fS)Nzfor %s = %s:%send)map_printlabellowerupperappend)rindices open_lines close_linesrvarstartstoprrr_get_loop_opening_ending{s  z*OctaveCodePrinter._get_loop_opening_endingcsb|jr|jrtj|jrdtj |St||\}}|dkr.t| |}d}nd}g}g}g}j dvr@| }nt |}|D]l} | j r| jr| jjr| jjr| jdkrj|t| j| j ddqGt| jdjd krt| jt r|| |t| j| j qG| jr| tjur| jd kr|t| j| jd kr|t| jqG|| qG|ptjg}fd d |D} fd d |D} |D]} | j|vrd | || j| || j<qdd} |s|| || St|d kr|djrdnd} || || | | dStdd|Drdnd} || || | d | || S)Nz%sir-)oldnoneF)evaluatercg|]}|qSr parenthesizerxprecrrr z0OctaveCodePrinter._print_Mul..crrrrrrrrrz(%s)cSsF|d}tdt|D]}||djrdnd}||||}q |S)Nrr*.*)rlen is_number)aa_strrrmulsymrrrmultjoins z.OctaveCodePrinter._print_Mul..multjoin/./cs|]}|jVqdSrr)rbirrrrz/OctaveCodePrinter._print_Mul..)r is_imaginaryr ImaginaryUnit is_Integerrr as_coeff_Mulrorderas_ordered_factorsr make_argsis_commutativeis_Powr4 is_Rational is_negativerrbaserargs isinstanceInfinityrrqOneindexall)rexprcer=rb pow_parenritemrb_strrdivsymrrr _print_Mulsf                  zOctaveCodePrinter._print_MulcCs,||j}||j}|j}d|||S)Nz{} {} {})rlhsrhsrel_opr)rrlhs_coderhs_codeoprrr_print_Relationals  z#OctaveCodePrinter._print_RelationalcCstdd|jDr dnd}t|}t|jdr d||jS|jrXt|jdr=|jjr/dnd }d |d||jSt|jd rX|jjrIdnd }d |d | |j|Sd | |j||| |j|fS)Ncsrrrrrrrrrz/OctaveCodePrinter._print_Pow..^z.^g?zsqrt(%s)grr1r%sz%s%s%s) rrr r r4rrrrr)rr powsymbolPRECsymrrr _print_Pows    zOctaveCodePrinter._print_PowcC(t|}d||j|||j|fS)Nz%s^%s)r rrr4rrrrrr _print_MatPow zOctaveCodePrinter._print_MatPowcCr)Nz%s \ %s)r rmatrixvectorrrrr_print_MatrixSolverz$OctaveCodePrinter._print_MatrixSolvecCdS)Npirrrrrr _print_PizOctaveCodePrinter._print_PicCr )N1irr rrr_print_ImaginaryUnitrz&OctaveCodePrinter._print_ImaginaryUnitcCr )Nzexp(1)rr rrr _print_Exp1rzOctaveCodePrinter._print_Exp1cCr )Nz (1+sqrt(5))/2rr rrr_print_GoldenRatiosz$OctaveCodePrinter._print_GoldenRatiocCsddlm}ddlm}ddlm}|j}|j}|jdsHt |j|rHg}g}|j D]\} } | ||| | | q*|t ||} | | S|jdr]||sW||r]|||S| |} | |} |d| | fS)Nr) Assignment) Piecewise) IndexedBaser}r|z%s = %s)sympy.codegen.astr$sympy.functions.elementary.piecewisersympy.tensor.indexedrrr _settingsrrrrrhas_doprint_loopsr)rrrrrrr expressions conditionsrrtemprrrrr_print_Assignments(        z#OctaveCodePrinter._print_AssignmentcCr )Ninfrr rrr_print_Infinity$rz!OctaveCodePrinter._print_InfinitycCr )Nz-infrr rrr_print_NegativeInfinity(rz)OctaveCodePrinter._print_NegativeInfinitycCr )NNaNrr rrr _print_NaN,rzOctaveCodePrinter._print_NaNcs ddfdd|DdS)N{, c3|]}|VqdSrrrrrrrr1z0OctaveCodePrinter._print_list..}joinr rr+r _print_list0s zOctaveCodePrinter._print_listcCr )Ntruerr rrr_print_BooleanTrue7rz$OctaveCodePrinter._print_BooleanTruecCr )Nfalserr rrr_print_BooleanFalse;rz%OctaveCodePrinter._print_BooleanFalsecCs t|Sr)strrr rrr _print_bool?rzOctaveCodePrinter._print_boolcsrjjfdkr dStjjvrdjjfSjjfdkr'dSddfddtjDS) N)rrz[]z zeros(%s, %s))rrz[%s]z; c3s4|]}dfdd|ddfDVqdS) cg|]}|qSrr)r*r+rrrPzAOctaveCodePrinter._print_MatrixBase...Nr.)rrArrrrPs,z6OctaveCodePrinter._print_MatrixBase..)rrrZerorrr/r)rr;rr:r_print_MatrixBaseGs  z#OctaveCodePrinter._print_MatrixBasecCsxddlm}|}|dd|Dg}|dd|Dg}|dd|Dg}d|||||||j|jfS)Nr)MatrixcSsg|]}|ddqS)rrrrkrrrrXrz.cSsg|]}|ddqS)rrr?rrrrYrcSsg|]}|dqS)rr?rrrrZszsparse(%s, %s, %s, %s, %s))sympy.matricesr>col_listrrr)rr;r>LIJAIJrrr_print_SparseRepMatrixTs z(OctaveCodePrinter._print_SparseRepMatrixcCs.|j|jtdddd|jd|jdfS)NAtomT)strictz(%s, %s)r)rparentr rrr rrr_print_MatrixElement_sz&OctaveCodePrinter._print_MatrixElementcsLfdd}|jd||j|jjdd||j|jjddS)Ncs|dd}|d}|d}|}||krdn|}|dkr8|dkr,||kr,dS||kr2|S|d|Sd|||fS)NrrrAr:)rr/)rlimlhsteplstrhstrr+rrstrslicees   z6OctaveCodePrinter._print_MatrixSlice..strslice(rr'r))rrKrowslicercolslice)rrrTrr+r_print_MatrixSliceds z$OctaveCodePrinter._print_MatrixSlicecs0fdd|jD}d|jjd|fS)Ncr8rr))rrr+rrrzr9z4OctaveCodePrinter._print_Indexed..z%s(%s)r')rrrrr/)rrindsrr+r_print_Indexedysz OctaveCodePrinter._print_Indexedcs&tddtfdd|jDS)Nrzdouble(%s == %s)c3s|] }|VqdSrrrrrrrsz:OctaveCodePrinter._print_KroneckerDelta..)r tuplerr rrr_print_KroneckerDelta~s z'OctaveCodePrinter._print_KroneckerDeltacsdfddjDS)Nrcsg|] }|tqSr)rr )rrBrrrrrsz.)r/rr rr^r_print_HadamardProductsz(OctaveCodePrinter._print_HadamardProductcCs*t|}d||j|||j|gS)Nz.**)r r/rrr4rrrr_print_HadamardPowers   z&OctaveCodePrinter._print_HadamardPowercsP|j}t|dkr|d|dkr|dg}dfdd|D}d|dS) NrArrr'c3r(rr))rnr+rrrr,z4OctaveCodePrinter._print_Identity..zeye(rV)rrr/)rrrsrr+r_print_Identitys   z!OctaveCodePrinter._print_IdentitycC$d||jd||jdS)Nz (gammainc({1}, {0}).*gamma({0}))rrrrrr rrr_print_lowergammasz#OctaveCodePrinter._print_lowergammacCrd)Nz)(gammainc({1}, {0}, 'upper').*gamma({0}))rrrer rrr_print_uppergammasz#OctaveCodePrinter._print_uppergammacCsd||jdtjS)Nzsinc(%s)r)rrrPir rrr _print_sincszOctaveCodePrinter._print_sinccCd||j||jfS)Nzbesselh(%s, 1, %s)rrargumentr rrr_print_hankel1  z OctaveCodePrinter._print_hankel1cCrj)Nzbesselh(%s, 2, %s)rkr rrr_print_hankel2rnz OctaveCodePrinter._print_hankel2cCDddlm}m}|j}|tjd|||jtj|}||S)Nr)sqrtr.rA) sympy.functionsrqr.rlrrhrHalfr)rrrqr.rexpr2rrr _print_jn$ zOctaveCodePrinter._print_jncCrp)Nr)rqr0rA) rrrqr0rlrrhrrsr)rrrqr0rrtrrr _print_ynrvzOctaveCodePrinter._print_yncCd||jdS)Nz airy(0, %s)rrrr rrr _print_airyaizOctaveCodePrinter._print_airyaicCrx)Nz airy(1, %s)rryr rrr_print_airyaiprimer{z$OctaveCodePrinter._print_airyaiprimecCrx)Nz airy(2, %s)rryr rrr _print_airybir{zOctaveCodePrinter._print_airybicCrx)Nz airy(3, %s)rryr rrr_print_airybiprimer{z$OctaveCodePrinter._print_airybiprimecCs*|j\}}|dkr||Sd||S)Nrz expint(%s))r_print_not_supportedr)rrmurrrr _print_expints  zOctaveCodePrinter._print_expintcsDt|jdks Jdjj|jjdfddt|jDdS)NrAz{name}({args})r'cr8rr)rr+rrrr9z?OctaveCodePrinter._one_or_two_reversed_args..)rr)rrrrr__name__r/reversedr rr+r_one_or_two_reversed_argss  z+OctaveCodePrinter._one_or_two_reversed_argsc Cs<dj|j|jj||jd||j|jdddS)Nz{name}({arg1}, {arg2})rr)rarg1arg2)rrrrrrfuncr rrr_nested_binary_math_funcs  z*OctaveCodePrinter._nested_binary_math_funcc s(|jdjdkr tdg}jdr?fdd|jddD}d|jdj}d||d t|}d |d St|jD]J\}\}}|d krY| d |n|t|jd krl|dkrl| dn | d||} | | |t|jd kr| dqDd|S)NrTzAll 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}cs(g|]\}}d||qS)z({0}).*({1}) + (~({0})).*()rr)rrrr+rrrs z6OctaveCodePrinter._print_Piecewise..rz ... rVrUrzif (%s)relsez elseif (%s)r ) rcond ValueErrorrrrr/r enumerater) rrrecpairselastpwrrrcode0rr+r_print_Piecewises,         z"OctaveCodePrinter._print_PiecewisecCs,t|jdkrd||jdS||S)Nrzzeta(%s)r)rrrrr rrr _print_zetas zOctaveCodePrinter._print_zetac st|tr||d}d|Sd}dddd|D}fdd|D}fd d|D}g}d }t|D]%\}} | d vrG|| q9|||8}|d ||| f|||7}q9|S) z0Accepts a string of code or a list of code linesTrz )z ^function z^if ^elseif ^else$z^for )z^end$rrcSsg|]}|dqS)z )lstrip)rlinerrrr$r9z1OctaveCodePrinter.indent_code..c&g|]ttfddDqS)c3|]}t|VqdSrr rrlrrrr&r,;OctaveCodePrinter.indent_code...intanyr) inc_regexrrr&cr)c3rrr rrrrr(r,rrr) dec_regexrrr(rr)rrz%s%s)rr5r splitlinesr/rr) rcode code_linestabincreasedecreaseprettylevelrarr)rrrrs.      zOctaveCodePrinter.indent_code)Fr __module__ __qualname____doc__ printmethodlanguage _operatorsrr r~__annotations__rrrrrrrrrrrrr rrrrr r"r#r%r0 _print_tuple _print_Tuple _print_Listr2r4r6r=rHrLrYr[r]r_r`rcrfrgrirmrorurwrzr|r}r~rr_print_DiracDelta_print_LambertWr _print_Max _print_Minrrr __classcell__rrrrrpAs    J  %rpNcKst|||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));' )rpdoprint)r assign_torrrr octave_code7s rcKstt|fi|dS)zPrints the Octave (or Matlab) representation of the given expression. See `octave_code` for the meaning of the optional arguments. N)printr)rrrrrprint_octave_codesrr)r __future__rtypingr sympy.corerrrrsympy.core.mulrsympy.core.numbersr sympy.printing.codeprinterr sympy.printing.precedencer r rlrrrrprrrrrrsx            y