~9\c2@ sdZddlmZmZddlmZmZmZmZddl m Z m Z ddl m Z ddlmZmZddlmZmZddlmZd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:g2Zid;d<6d=d>6d?d@6dAdB6dCdD6dEdF6dGdH6ZdIefdJYZedKZdLZdMS(Ns 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. i(tprint_functiontdivision(tMultPowtStRational(t string_typestrange(t _keep_coeff(t CodePrintert Assignment(t precedencet PRECEDENCE(tsearchtsintcosttantcottsectcsctasintacostatantacottasectacsctsinhtcoshttanhtcothtsechtcschtasinhtacoshtatanhtacothtasecht acschsinctatan2tsigntfloortlogtexptcbrttsqrtterfterfcterfit factorialtgammatdigammattrigammat polygammatbetatairyait airyaiprimetairybit airybiprimetbesseljtbesselytbesselitbesselkterfinvterfcinvtabstAbstceiltceilingtconjt conjugatethankelh1thankel1thankelh2thankel2timagtimtrealtretJuliaCodePrintercB seZdZdZdZidd6dd6dd6Zid8d 6d d 6d d 6id6ed6ed6ed6ed6Z idZ dZ dZ dZ dZdZdZdZdZdZdZdZdZd Zd!Zd"Zd#Zd$Zd%Zd&Zd'Zd(Zd)Z e Z!d*Z"d+Z#d,Z$d-Z%d.Z&e%Z'Z(Z)Z*Z+e&Z,Z-d/Z.d0Z/d1Z0d2Z1d3Z2d4Z3d5Z4d6Z5d7Z6RS(9sD A printer to convert expressions to strings of Julia code. t_juliatJulias&&tands||tort!tnottordertautot full_precit precisiontuser_functionsthumantallow_unknown_functionstcontracttinlinecC sjtt|j|tttt|_|jjtt|j di}|jj|dS(NRY( tsuperRNt__init__tdicttziptknown_fcns_src1tknown_functionstupdatetknown_fcns_src2tget(tselftsettingst userfuncs((s3lib/python2.7/site-packages/sympy/printing/julia.pyR_Is cC s|dS(Ni((Rgtp((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_rate_index_positionQscC sd|S(Ns%s((Rgt codestring((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_get_statementUscC s dj|S(Ns# {0}(tformat(Rgttext((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _get_commentYscC sdj||S(Nsconst {0} = {1}(Rn(Rgtnametvalue((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_declare_number_const]scC s |j|S(N(t indent_code(Rgtlines((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _format_codeasc s)|j\}fdt|DS(Nc3 s.|]$}tD]}||fVqqdS(N(R(t.0tjti(trows(s3lib/python2.7/site-packages/sympy/printing/julia.pys hs(tshapeR(Rgtmattcols((Rzs3lib/python2.7/site-packages/sympy/printing/julia.pyt_traverse_matrix_indicesescC sg}g}xj|D]b}t|j|j|jd|jdg\}}}|jd|||f|jdqW||fS(Nisfor %s = %s:%stend(tmapt_printtlabeltlowertuppertappend(Rgtindicest open_linest close_linesRytvartstarttstop((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_get_loop_opening_endingks  ,cC su|jr>|jr>|jdjr>d|jtj |St|}|j\}}|dkrt| |}d}nd}g}g}g}|j dkr|j } nt j |} xC| D];} | j r| jr| jjr| jjr| jdkr2|jt| j| j dtqt| jdjd krpt| jt rp|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| |^qJ} xJ|D]B} | j|krod | |j| j| |j| j,st](tjoin(RgR((Rgs3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_list+scC s?t|dkr'd|j|dSd|j|dSdS(Nis(%s,)is(%s)s, (RRt stringify(RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_tuple/scC sdS(Nttrue((RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_BooleanTrue7scC sdS(Ntfalse((RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_BooleanFalse;scC st|jS(N(tstrR(RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_bool?sc C s|jdks|jdkr2d|j|jfS|j|jfd krVd|dS|jdkrd|j|dddddd S|jdkrdd jg|D]}|j|^qSd|j|ddddd d dd S(Nis zeros(%s, %s)is[%s]trowstartRtrowendtcolsept s, trowseps; (ii(ii(RzR}ttableRR(RgtAR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_MatrixBaseGs #-cC sddlm}|j}|g|D]}|dd^q&}|g|D]}|dd^qM}|g|D]}|d^qt}d|j||j||j||j|jfS(Ni(tMatrixiiissparse(%s, %s, %s, %s, %s)(tsympy.matricesRtcol_listRRzR}(RgRRtLtktItJtAIJ((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_SparseMatrixVs ''#cC s9|j|jtddtd|jd|jdfS(NtAtomtstricts[%s,%s]i(RtparentR tTrueRyRx(RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_MatrixElementosc 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(Rg(s3lib/python2.7/site-packages/sympy/printing/julia.pytstrsliceus  !  t[it,iR(RRtrowsliceR{tcolslice(RgRR ((Rgs3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_MatrixSlicetscC sKg|jD]}|j|^q }d|j|jjdj|fS(Ns%s[%s]R (RRRRR(RgRRytinds((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_Indexeds%cC s|j|jS(N(RR(RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_IdxscC sd|j|jdS(Nseye(%s)i(RR{(RgR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_IdentityscC sZddlm}m}|j}|tjd|||jtj|}|j|S(Ni(R,R:i( tsympy.functionsR,R:targumentRtPiRURR(RgRR,R:Rtexpr2((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_jns .cC sZddlm}m}|j}|tjd|||jtj|}|j|S(Ni(R,R;i( RR,R;RRRRURR(RgRR,R;RR((s3lib/python2.7/site-packages/sympy/printing/julia.pyt _print_yns .c C s|jdjtkr%tdng}|jdrg|jd D]0\}}dj|j||j|^qF}d|j|jdj}dj||}d|dSxt |jD]\}\}}|d kr|j d |j|nO|t |jd kr8|tkr8|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}) :s (%s)s t(t)isif (%s)itelses elseif (%s)R( RtcondRt ValueErrorRRnRRRt enumerateRR( RgRRuRRtecpairstelasttpwRytcode0((s3lib/python2.7/site-packages/sympy/printing/julia.pyt_print_Piecewises( A " % c 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$( RRRtt splitlinesRRtlstriptinttanyR RR( Rgtcodet code_linesttabt inc_regext dec_regextlineRMtincreasetdecreasetprettytleveltn((s3lib/python2.7/site-packages/sympy/printing/julia.pyRts* ">> N(7t__name__t __module__t__doc__t printmethodtlanguaget _operatorstNoneRRt_default_settingsR_RkRmRpRsRvR~RRRRRRRRRRRRRRRRt _print_TupleRRRRRt _print_Matrixt_print_DenseMatrixt_print_MutableDenseMatrixt_print_ImmutableMatrixt_print_ImmutableDenseMatrixt_print_MutableSparseMatrixt_print_ImmutableSparseMatrixRRRRRRRR$Rt(((s3lib/python2.7/site-packages/sympy/printing/julia.pyRN.sp          K                            %cK st|j||S(s Converts `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, Abs >>> 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, 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])) >>> julia_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])./(t[i + 1] - t[i])' (RNtdoprint(Rt assign_toRh((s3lib/python2.7/site-packages/sympy/printing/julia.pyt julia_codescK stt||dS(s~Prints the Julia representation of the given expression. See `julia_code` for the meaning of the optional arguments. N(tprintRF(RRh((s3lib/python2.7/site-packages/sympy/printing/julia.pytprint_julia_codessN(R6t __future__RRt sympy.coreRRRRtsympy.core.compatibilityRRtsympy.core.mulRtsympy.printing.codeprinterR R tsympy.printing.precedenceR R RMR RbReRNR:RFRH(((s3lib/python2.7/site-packages/sympy/printing/julia.pyt s<"