B e‹djXã3@sdZddlmZmZddlmZmZmZm Z ddl mZddlm Z ddlmZmZddlmZdd d ddd ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:g3Zd;dd?d@dAdBœZGdCdD„dDe ƒZdJdFdG„ZdHdI„ZdES)Ka Julia code printer The `JuliaCodePrinter` converts SymPy expressions into Julia expressions. A complete code generator, which uses `julia_code` extensively, can be found in `sympy.utilities.codegen`. The `codegen` module can be used to generate complete source code files. é)ÚAnyÚDict)ÚMulÚPowÚSÚRational)Ú_keep_coeff)ÚCodePrinter)Ú precedenceÚ PRECEDENCE)ÚsearchÚsinÚcosÚtanZcotÚsecZcscÚasinÚacosÚatanZacotZasecZacscÚsinhÚcoshÚtanhZcothZsechZcschÚasinhÚacoshÚatanhZacothZasechZacschZsincÚatan2ÚsignÚfloorÚlogÚexpZcbrtÚsqrtÚerfÚerfcZerfiÚ factorialÚgammaZdigammaZtrigammaZ polygammaÚbetaZairyaiZairyaiprimeZairybiZairybiprimeÚbesseljÚbesselyZbesseliZbesselkZerfinvZerfcinvÚabsÚceilZconjZhankelh1Zhankelh2ÚimagÚreal)ZAbsZceilingÚ conjugateZhankel1Zhankel2ÚimÚrec sžeZdZdZdZdZddddœZdd d iddddd œZif‡fdd„ Zdd„Z dd„Z dd„Zdd„Zdd„Z dd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Z‡fd&d'„Zd(d)„Z‡fd*d+„Z‡fd,d-„Z‡fd.d/„Z‡fd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Zdd?„Z!d@dA„Z"dBdC„Z#dDdE„Z$dFdG„Z%dHdI„Z&dJdK„Z'dLdM„Z(dNdO„Z)dPdQ„Z*dRdS„Z+dTdU„Z,dVdW„Z-dXdY„Z.dZd[„Z/d\d]„Z0‡Z1S)^ÚJuliaCodePrinterzD A printer to convert expressions to strings of Julia code. Z_juliaÚJuliaz&&z||ú!)ÚandÚorÚnotNÚautoéTF)ÚorderZ full_precÚ precisionÚuser_functionsZhumanZallow_unknown_functionsÚcontractÚinlinecsHtƒ |¡ttttƒƒ|_|j ttƒ¡| di¡}|j |¡dS)Nr8) ÚsuperÚ__init__ÚdictÚzipÚknown_fcns_src1Zknown_functionsÚupdateÚknown_fcns_src2Úget)ÚselfÚsettingsZ userfuncs)Ú __class__©úa/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/printing/julia.pyr<Is zJuliaCodePrinter.__init__cCs|dS)NérF)rCÚprFrFrGÚ_rate_index_positionQsz%JuliaCodePrinter._rate_index_positioncCsd|S)Nz%srF)rCZ codestringrFrFrGÚ_get_statementUszJuliaCodePrinter._get_statementcCs d |¡S)Nz# {})Úformat)rCÚtextrFrFrGÚ_get_commentYszJuliaCodePrinter._get_commentcCsd ||¡S)Nz const {} = {})rL)rCÚnameÚvaluerFrFrGÚ_declare_number_const]sz&JuliaCodePrinter._declare_number_constcCs | |¡S)N)Úindent_code)rCÚlinesrFrFrGÚ_format_codeaszJuliaCodePrinter._format_codecs |j\‰}‡fdd„t|ƒDƒS)Nc3s$|]}tˆƒD]}||fVqqdS)N)Úrange)Ú.0ÚjÚi)ÚrowsrFrGú hsz.)ÚshaperU)rCÚmatÚcolsrF)rYrGÚ_traverse_matrix_indiceses z)JuliaCodePrinter._traverse_matrix_indicescCsbg}g}xP|D]H}t|j|j|jd|jdgƒ\}}}| d|||f¡| d¡qW||fS)Nézfor %s = %s:%sÚend)ÚmapÚ_printÚlabelÚlowerÚupperÚappend)rCÚindicesZ open_linesZclose_linesrXÚvarÚstartÚstoprFrFrGÚ_get_loop_opening_endingks z)JuliaCodePrinter._get_loop_opening_endingcsŒ|jr0|jr0| ¡djr0dˆ tj|¡St|ƒ‰| ¡\}}|dkr^t||ƒ}d}nd}g}g}g}ˆj dkr‚| ¡}n t |¡}xô|D]ì} | j r&| jr&| jjr&| jjr&| jdkrà| t| j| jdd¡nDt| jdjƒd krt| jtƒr| | ¡| t| j| jƒ¡q’| jrt| tjk rt| jd krV| t| jƒ¡| jd kr~| t| jƒ¡q’| | ¡q’W|pŽtjg}‡‡fd d„|Dƒ} ‡‡fdd„|Dƒ}x:|D]2} | j|kr¾d || | j¡|| | j¡<q¾Wdd„}|s|||| ƒSt|ƒd krL|djr.dnd} |||| ƒ| |dStdd„|Dƒƒrddnd} |||| ƒ| d |||ƒSdS)Nrz%simú-Ú)ÚoldÚnoneéÿÿÿÿF)Úevaluater_csg|]}ˆ |ˆ¡‘qSrF)Úparenthesize)rVÚx)ÚprecrCrFrGú ¦sz/JuliaCodePrinter._print_Mul..csg|]}ˆ |ˆ¡‘qSrF)rr)rVrs)rtrCrFrGru§sz(%s)cSsJ|d}x.multjoinú/z./css|]}|jVqdS)N)rx)rVZbirFrFrGrZ½sz.JuliaCodePrinter._print_Mul..)rxZis_imaginaryZas_coeff_MulÚ is_integerrbrZ ImaginaryUnitr rr6Zas_ordered_factorsrZ make_argsÚis_commutativeZis_PowrZis_RationalZis_negativerfrÚbaserwÚargsÚ isinstanceÚInfinityrIrÚqÚOneÚindexÚall)rCÚexprÚcÚerryÚbZ pow_parenrÚitemrzZb_strr|ZdivsymrF)rtrCrGÚ _print_MulwsV $ &zJuliaCodePrinter._print_MulcCs,| |j¡}| |j¡}|j}d |||¡S)Nz{} {} {})rbÚlhsÚrhsZrel_oprL)rCrˆÚlhs_codeÚrhs_codeÚoprFrFrGÚ_print_RelationalÁsz"JuliaCodePrinter._print_RelationalcCsÖtdd„|jDƒƒrdnd}t|ƒ}|jtjkr@d| |j¡S|jr´|jtjkr||jj r`dnd}d|d| |j¡S|jtj kr´|jj r–dnd}d|d | |j|¡Sd | |j|¡|| |j|¡fS)Ncss|]}|jVqdS)N)rx)rVrsrFrFrGrZÈsz.JuliaCodePrinter._print_Pow..ú^z.^zsqrt(%s)r}z./Ú1z%sz%s%s%s)r‡rr rrÚHalfrbr€rrxr…rr)rCrˆZ powsymbolÚPRECÚsymrFrFrGÚ _print_PowÇszJuliaCodePrinter._print_PowcCs(t|ƒ}d| |j|¡| |j|¡fS)Nz%s^%s)r rrr€r)rCrˆr—rFrFrGÚ _print_MatPowÛszJuliaCodePrinter._print_MatPowcs|jdrdStƒ |¡SdS)Nr:Úpi)Ú _settingsr;Ú_print_NumberSymbol)rCrˆ)rErFrGÚ _print_Piás zJuliaCodePrinter._print_PicCsdS)Nr,rF)rCrˆrFrFrGÚ_print_ImaginaryUnitèsz%JuliaCodePrinter._print_ImaginaryUnitcs|jdrdStƒ |¡SdS)Nr:rŠ)rœr;r)rCrˆ)rErFrGÚ_print_Exp1ìs zJuliaCodePrinter._print_Exp1cs|jdrdStƒ |¡SdS)Nr:Z eulergamma)rœr;r)rCrˆ)rErFrGÚ_print_EulerGammaós z"JuliaCodePrinter._print_EulerGammacs|jdrdStƒ |¡SdS)Nr:Úcatalan)rœr;r)rCrˆ)rErFrGÚ_print_Catalanús zJuliaCodePrinter._print_Catalancs|jdrdStƒ |¡SdS)Nr:Zgolden)rœr;r)rCrˆ)rErFrGÚ_print_GoldenRatios z#JuliaCodePrinter._print_GoldenRatiocCsèddlm}ddlm}ddlm}|j}|j}|jds”t |j|ƒr”g}g}x,|j D]"\} } | ||| ƒ¡| | ¡qVW|t||ƒŽ}| |¡S|jdr¾| |¡s²| |¡r¾| ||¡S| |¡}| |¡} | d|| f¡SdS)Nr)Ú Assignment)Ú Piecewise)ÚIndexedBaser:r9z%s = %s)Zsympy.codegen.astr¥Z$sympy.functions.elementary.piecewiser¦Zsympy.tensor.indexedr§rŽrrœr‚rrfr>rbÚhasZ_doprint_loopsrK)rCrˆr¥r¦r§rŽrZexpressionsZ conditionsrŠr‰Útemprr‘rFrFrGÚ_print_Assignments& z"JuliaCodePrinter._print_AssignmentcCsdS)NZInfrF)rCrˆrFrFrGÚ_print_Infinity%sz JuliaCodePrinter._print_InfinitycCsdS)Nz-InfrF)rCrˆrFrFrGÚ_print_NegativeInfinity)sz(JuliaCodePrinter._print_NegativeInfinitycCsdS)NÚNaNrF)rCrˆrFrFrGÚ _print_NaN-szJuliaCodePrinter._print_NaNcs dd ‡fdd„|Dƒ¡dS)NzAny[z, c3s|]}ˆ |¡VqdS)N)rb)rVry)rCrFrGrZ2sz/JuliaCodePrinter._print_list..ú])Újoin)rCrˆrF)rCrGÚ_print_list1szJuliaCodePrinter._print_listcCs2t|ƒdkrd| |d¡Sd| |d¡SdS)Nr_z(%s,)rz(%s)z, )rwrbÚ stringify)rCrˆrFrFrGÚ_print_tuple5szJuliaCodePrinter._print_tuplecCsdS)NÚtruerF)rCrˆrFrFrGÚ_print_BooleanTrue=sz#JuliaCodePrinter._print_BooleanTruecCsdS)NÚfalserF)rCrˆrFrFrGÚ_print_BooleanFalseAsz$JuliaCodePrinter._print_BooleanFalsecCst|ƒ ¡S)N)Ústrrd)rCrˆrFrFrGÚ_print_boolEszJuliaCodePrinter._print_boolcs–tj|jkrd|j|jfS|j|jfdkr8d|dS|jdkrXd|jˆddddS|jdkr~dd ‡fd d„|Dƒ¡Sd|jˆddddd S)Nz zeros(%s, %s))r_r_z[%s])rrr_rmú )ÚrowstartÚrowendÚcolsepz, csg|]}ˆ |¡‘qSrF)rb)rVry)rCrFrGruWsz6JuliaCodePrinter._print_MatrixBase..z; )r»r¼Zrowsepr½)rZZeror[rYr]Útabler°)rCÚArF)rCrGÚ_print_MatrixBaseMs z"JuliaCodePrinter._print_MatrixBasecCsrddlm}| ¡}|dd„|Dƒƒ}|dd„|Dƒƒ}|dd„|Dƒƒ}d| |¡| |¡| |¡|j|jfS)Nr)ÚMatrixcSsg|]}|dd‘qS)rr_rF)rVÚkrFrFrGru`sz;JuliaCodePrinter._print_SparseRepMatrix..cSsg|]}|dd‘qS)r_rF)rVrÂrFrFrGruascSsg|]}|d‘qS)érF)rVrÂrFrFrGrubszsparse(%s, %s, %s, %s, %s))Zsympy.matricesrÁZcol_listrbrYr])rCr¿rÁÚLÚIÚJZAIJrFrFrGÚ_print_SparseRepMatrix\sz'JuliaCodePrinter._print_SparseRepMatrixcCs.|j|jtdddd|jd|jdfS)NZAtomT)Ústrictz[%s,%s]r_)rrÚparentrrXrW)rCrˆrFrFrGÚ_print_MatrixElementgsz%JuliaCodePrinter._print_MatrixElementcsL‡fdd„}ˆ |j¡d||j|jjdƒd||j|jjdƒdS)NcsŒ|dd}|d}|d}ˆ |¡}||kr2dnˆ |¡}|dkrr|dkrX||krXdS||krd|S|d|Snd |ˆ |¡|f¡SdS)Nrr_rÃr`ú:)rbr°)rsZlimÚlÚhÚstepZlstrZhstr)rCrFrGÚstrslicems z5JuliaCodePrinter._print_MatrixSlice..strsliceú[rú,r_r¯)rbrÉZrowslicer[Zcolslice)rCrˆrÏrF)rCrGÚ_print_MatrixSlicelsz#JuliaCodePrinter._print_MatrixSlicecs0‡fdd„|jDƒ}dˆ |jj¡d |¡fS)Ncsg|]}ˆ |¡‘qSrF)rb)rVrX)rCrFrGru‚sz3JuliaCodePrinter._print_Indexed..z%s[%s]rÑ)rgrbr€rcr°)rCrˆZindsrF)rCrGÚ_print_IndexedszJuliaCodePrinter._print_IndexedcCs| |j¡S)N)rbrc)rCrˆrFrFrGÚ _print_Idx†szJuliaCodePrinter._print_IdxcCsd| |jd¡S)Nzeye(%s)r)rbr[)rCrˆrFrFrGÚ_print_IdentityŠsz JuliaCodePrinter._print_Identitycsd ‡‡fdd„ˆjDƒ¡S)Nz.*csg|]}ˆ |tˆƒ¡‘qSrF)rrr )rVÚarg)rˆrCrFrGruŽsz;JuliaCodePrinter._print_HadamardProduct..)r°r)rCrˆrF)rˆrCrGÚ_print_HadamardProductsz'JuliaCodePrinter._print_HadamardProductcCs*t|ƒ}d | |j|¡| |j|¡g¡S)Nz.**)r r°rrr€r)rCrˆr—rFrFrGÚ_print_HadamardPower‘sz%JuliaCodePrinter._print_HadamardPowercCsDddlm}m}|j}|tjd|ƒ||jtj|ƒ}| |¡S)Nr)rr%rÃ) Úsympy.functionsrr%ÚargumentrÚPir6r–rb)rCrˆrr%rsÚexpr2rFrFrGÚ _print_jn™s$zJuliaCodePrinter._print_jncCsDddlm}m}|j}|tjd|ƒ||jtj|ƒ}| |¡S)Nr)rr&rÃ) rÙrr&rÚrrÛr6r–rb)rCrˆrr&rsrÜrFrFrGÚ _print_yn s$zJuliaCodePrinter._print_ync s$|jdjdkrtdƒ‚g}ˆjdrr‡fdd„|jdd…Dƒ}dˆ |jdj¡}d |¡|}d |d Sx¢t|jƒD]”\}\}}|dkr¨| dˆ |¡¡n:|t |jƒd krÎ|dkrÎ| d¡n| dˆ |¡¡ˆ |¡} | | ¡|t |jƒd kr~| d¡q~Wd |¡SdS)NrpTz¼All 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 ({}) ? ({}) :)rLrb)rVrŠr‰)rCrFrGruµsz5JuliaCodePrinter._print_Piecewise..z (%s)Ú ú(ú)rzif (%s)r_Úelsezelseif (%s)r`) rZcondÚ ValueErrorrœrbrˆr°Ú enumeraterfrw) rCrˆrSZecpairsZelastÚpwrXrŠr‰Zcode0rF)rCrGÚ_print_Piecewise§s( z!JuliaCodePrinter._print_Piecewisec sÆt|tƒr$| | d¡¡}d |¡Sd}d‰d‰dd„|Dƒ}‡fdd„|Dƒ}‡fd d„|Dƒ}g}d }xVt|ƒD]J\}} | dkr| | ¡qt|||8}| d||| f¡|||7}qtW|S) z0Accepts a string of code or a list of code linesTrmz )z ^function z^if z^elseif z^else$z^for )z^end$z^elseif z^else$cSsg|]}| d¡‘qS)z )Úlstrip)rVÚlinerFrFrGruÙsz0JuliaCodePrinter.indent_code..cs&g|]‰tt‡fdd„ˆDƒƒƒ‘qS)c3s|]}t|ˆƒVqdS)N)r)rVr-)rèrFrGrZÛsz:JuliaCodePrinter.indent_code...)ÚintÚany)rV)Ú inc_regex)rèrGruÛscs&g|]‰tt‡fdd„ˆDƒƒƒ‘qS)c3s|]}t|ˆƒVqdS)N)r)rVr-)rèrFrGrZÝsz:JuliaCodePrinter.indent_code...)rérê)rV)Ú dec_regex)rèrGruÝsr)rmrßz%s%s)r‚r¸rRÚ splitlinesr°rärf) rCÚcodeZ code_linesÚtabZincreaseZdecreaseÚprettyÚlevelÚnrèrF)rìrërGrRÌs* zJuliaCodePrinter.indent_code)2Ú__name__Ú __module__Ú__qualname__Ú__doc__ZprintmethodÚlanguageÚ _operatorsZ_default_settingsr<rJrKrNrQrTr^rkrr“r™ršržrŸr r¡r£r¤rªr«r¬r®r±r³Z_print_Tuplerµr·r¹rÀrÇrÊrÒrÓrÔrÕr×rØrÝrÞrærRÚ __classcell__rFrF)rErGr..snJ%r.NcKst|ƒ ||¡S)aConverts `expr` to a string of Julia 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 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 julia_code, symbols, sin, pi >>> x = symbols('x') >>> julia_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") >>> julia_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 possible in Julia to write "vectorized" code. It is harmless if the values are scalars. >>> julia_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) >>> julia_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: >>> julia_code(x**2*y*A**3) '(x.^2.*y)*A^3' Matrices are supported using Julia 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)]]) >>> julia_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)) >>> julia_code(pw, assign_to=tau) 'tau = ((x > 0) ? (x + 1) : (x))' Note that any expression that can be generated normally can also exist inside a Matrix: >>> mat = Matrix([[x**2, pw, sin(x)]]) >>> julia_code(mat, assign_to='A') 'A = [x.^2 ((x > 0) ? (x + 1) : (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 Julia function. >>> from sympy import Function >>> f = Function('f') >>> g = Function('g') >>> custom_functions = { ... "f": "existing_julia_fcn", ... "g": [(lambda x: x.is_Matrix, "my_mat_fcn"), ... (lambda x: not x.is_Matrix, "my_fcn")] ... } >>> mat = Matrix([[1, x]]) >>> julia_code(f(x) + g(x) + g(mat), user_functions=custom_functions) 'existing_julia_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])) >>> julia_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])./(t[i + 1] - t[i])' )r.Zdoprint)rˆZ assign_torDrFrFrGÚ julia_codeìsrúcKstt|f|ŽƒdS)z~Prints the Julia representation of the given expression. See `julia_code` for the meaning of the optional arguments. N)Úprintrú)rˆrDrFrFrGÚprint_julia_codeusrü)N)röÚtypingrrZtDictZ sympy.corerrrrZsympy.core.mulrZsympy.printing.codeprinterr Zsympy.printing.precedencer rr-rr?rAr.rúrürFrFrFrGÚ s> A