~9\c@ sZdZddlmZmZddlmZddlmZddlZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/m0Z0dd l1m2Z2dd l3m4Z4dd l5m6Z6dd l7m8Z8ddl9m:Z:m;Z;ddl<m=Z=idd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd6dd 6d!d"6d#d$6Z>d%e8fd&YZ?e@d'ZAd(ZBdS()sq Fortran code printer The FCodePrinter converts single sympy expressions into single Fortran expressions, using the functions defined in the Fortran 77 standard where possible. Some useful pointers to Fortran can be found on wikipedia: https://en.wikipedia.org/wiki/Fortran Most of the code below is based on the "Professional Programmer's Guide to Fortran77" by Clive G. Page: http://www.star.le.ac.uk/~cgp/prof77.html Fortran is a case-insensitive language. This might cause trouble because SymPy is case sensitive. So, fcode adds underscores to variable names when it is necessary to make them different for Fortran. i(tprint_functiontdivision(t defaultdict(tchainN(t Assignmentt DeclarationtPointert value_consttfloat32tfloat64tfloat80t complex64t complex128tint8tint16tint32tint64tintctrealtintegertbool_tcomplex_( t allocatabletisigntdsigntcmplxtmerget literal_dpt elementaltpuret intent_int intent_outt intent_inout(tStAddtNtFloattSymbol(t string_typestrange(tFunction(tEq(tRange(t CodePrinter(t precedencet PRECEDENCE(tprinter_contexttsintcosttantasintacostatantatan2tsinhtcoshttanhtlogtexpterftabstAbstconjgt conjugatetmaxtMaxtmintMint FCodePrintercB sLeZdZdZdZiee6ee6e e 6Z i de 6de 6de6de6de6de 6d e6d e6d e6d e6d e6Ziidd6e 6Zi dgd6dd6dd6id6ed6ed6dd6ed6dd6ed6Zidd6d d!6d"d#6d$d%6d&d'6Zid(d)6Zid*Zed+Zd,Zd-Z d.Z!d/Z"d0Z#d1Z$d2Z%d3Z&d4Z'd5Z(d6Z)d7Z*d8Z+d9Z,d:Z-d;Z.d<Z/d=Z0d>Z1d?Z2d@Z3dAZ4dBZ5dCZ6dDZ7dEZ8dFZ9dGZ:dHZ;dIZ<dJZ=dKZ>dLZ?dMZ@dNZAdOZBdPZCdQZDdRZEdSZFdTZGdUZHdVZIdWZJdXZKdYZLdZZMd[ZNd\ZOd]ZPd^ZQd_ZRd`ZSdaZTdbZUdcZVddZWdeZXdfZYRS(hsAA printer to convert sympy expressions to strings of Fortran codet_fcodetFortransinteger(c_int)sreal*4sreal*8sreal*10s complex*8s complex*16s integer*1s integer*2s integer*4s integer*8tlogicaltc_intt iso_c_bindingtordertautot full_precit precisiontuser_functionsthumantallow_unknown_functionstfixedt source_formattcontractiMtstandardt name_manglings.and.tands.or.tors.neqv.txors.eqv.t equivalents.not. tnots/=s!=cC si|_g|_tt|jj|jdij|_tt|jj|jdij|_tt |j |tt |_ |j di}|j j |dddddd h}|jd |krtd |jd ntt|_dS( Nt type_aliasest type_mappingsRNiBiMiZi_iiRTsUnknown Fortran standard: %s(tmangled_symbolst used_nametdictRR[titemstpopR\tsuperRDt__init__tknown_functionstgettupdatet _settingst ValueErrorRtsett module_uses(tselftsettingst userfuncst standards((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRcxs  !! cC ss|jddkr,idd6dd6dd6S|jdd krXid d6dd6d d6Std |jddS( NRRRQs tcodes @ tcontsC tcommenttfreets! sUnknown source format: %s(RgRh(Rk((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_leads cC s|jdtkr||jkr|j}x#|j|jkrP|d7}q.W|jj|j||jkr||j|s(tshapeR'(Rktmattcols((Rs3lib/python2.7/site-packages/sympy/printing/fcode.pyt_traverse_matrix_indicesscC sg}g}xj|D]b}t|j|j|jd|jdg\}}}|jd|||f|jdqW||fS(Nisdo %s = %s, %ssend do(tmapRtlabelRxtupperRy(Rktindicest open_linest close_linesRtvartstarttstop((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_get_loop_opening_endings  ,cC sddlm}|j\}|jrLtdtd|t|d}n|jrttt dt d|||t||t d}n6tt dt t d|t|t d}|j |S(Ni(R=ii( tsympyR=targst is_integerRRR)t is_complexRRRR(RkR|R=targtnew_expr((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_signs  ' I6c C s|jdjtkr%tdng}|jtrxt|jD]\}\}}|dkr|jd|j|nO|t |jdkr|tkr|jdn|jd|j||j|j|qJW|jdd j |S|j d d krd }|j|jdj }t |jd }xX|r|j\}}|j|}|j|} |jd |d|d| }qPW|StddS(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.is if (%s) thenitelseselse if (%s) thensend ifs RTi_smerge({T}, {F}, {COND})tTtFtCONDsmUsing Piecewise as an expression using inline operators is not supported in standards earlier than Fortran95.(RtcondRvRhthasRt enumerateRyRtlentjoinRgR|tlistRaRtNotImplementedError( RkR|RRtetctpatternRottermsR((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Piecewises0" %   "cC s:dj|j|jtddt|jd|jdS(Ns {0}({1}, {2})tAtomtstricti(Rt parenthesizetparentR-RvRR(RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_MatrixElementsc C svg}g}g}xb|jD]W}|jrD|jrD|j|q|jrf|jrf|j|q|j|qW|rb|r+t|}t|}|j|}|jdrd} |d}nd} t||krd|}nd|jt||jt j t|| |fSd|jt||jt j t|fSnt j ||SdS(Nt-it+s(%s)scmplx(%s,%s) %s %ss cmplx(%s,%s)( Rt is_numbertis_realRyt is_imaginaryR,R"Rt startswithR!t ImaginaryUnitR+t _print_Add( RkR|t pure_realtpure_imaginarytmixedRtPRECttermtttsign((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRs8     "cC sz|jd}g|jD]}t||^q}|j|}t|ts]|j|Stj||j|SdS(NRM( RgRR#tfunct isinstanceR(RR+t_print_Function(RkR|tprectaRt eval_expr((s3lib/python2.7/site-packages/sympy/printing/fcode.pyR)s  % cC s]|jddkr(d}t|n1|j\}}dj|j||j|SdS(NRTiBiMs]Python % operator and SymPy's Mod() function are not supported by Fortran 66 or 77 standards.s modulo({}, {})(iBiM(RgRRRR(RkR|tmsgtxty((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Mod3s cC sdS(Ns cmplx(0,1)((RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_ImaginaryUnit@scC s t|S(N(R(RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_intDscC s?|jr+|jr+d|jtj |Stj||SdS(Ns cmplx(0,%s)(RRRR!RR+t _print_Mul(RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRGscC st|}|jdkrGd|jtd|j|j|fS|jdkr|jjr|jjrd|j|jSd|j|jSqd|j|jSntj ||SdS(Nis%s/%sig?s sqrt(%s.0d0)ssqrt(dble(%s))ssqrt(%s)( R,R:RRRtbaseRt is_NumberR+t _print_Pow(RkR|R((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRPs   cC s-t|jt|j}}d||fS(Ns %d.0d0/%d.0d0(tintR}tq(RkR|R}R((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_RationalcscC sOtj||}|jd}|dkrGd|| ||dfSd|S(NRis%sd%sis%sd0(R+t _print_Floattfind(RkR|tprintedR((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRgs  cC sKg|jD]}|j|^q }d|j|jjdj|fS(Ns%s(%s)s, (RRRRR(RkR|Rtinds((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Indexedns%cC s|j|jS(N(RR(RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Idxrsc sXj|j}j|j}jdjtfd||j|gS(Ns{0} = {0} {1} {2}c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pytyRs(RtlhstrhsRRRtbinop(RkR|tlhs_codetrhs_code((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_AugmentedAssignmentus  cC s|j|j}|jdkr>|d|j|j7}n|jdkrj|d|j|j7}nd|jjjd|fS(Ns, s, mask=s%s(%s)Ru(RtarraytdimtNonetmaskt __class__t__name__trstrip(Rktsmtparams((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_sum_|s cC s |j|S(N(R(Rktprod((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_product_sc sydg}|jdkr.|jdd}nd}d|djd|jrTdnd|jd fd d |S( Nt concurrentitstepRss, {step}s*do {concurrent}{counter} = {first}, {last}s {body} end do s concurrent tapplyc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRstexclude(RRyRRtkwargs(RktdotexclR((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Dos   c sE|jdkrdnd}d|dj|jdfdS(NiRss, {step}s$({expr}, {counter} = {first}, {last}t)Rc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RRR(RktidlR((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_ImpliedDoLoopsc C s|j|j}t|jtr<|jj\}}}n td|j|j}djd|d|d|d|d|S(Ns*Only iterable currently supported is Ranges3do {target} = {start}, {stop}, {step} {body} end dottargetRRRtbody( RRRtiterableR*RRRR(RkR|RRRRR((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Fors  c s4|j\}}djtfd||fS(Ns == c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RRR(RkR|RR((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Equalitysc s4|j\}}djtfd||fS(Ns /= c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RRR(RkR|RR((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_UnequalityscC sw|jj||}|jj||j}|jj|}|rsx+|D] \}}|j|j|qLWn|S(N(R[ReR\Rwt type_modulesRjR(Rkttype_ttype_strRjtktv((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Typesc s@djdj|jddjtfd|jS(Ns{symbol}({idxs})tsymboltidxss, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RRRRRR(Rktelem((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Elements cC s t|S(N(R(Rktext((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Extentsc s|j}|j}|jd}gtttfD]}||jk^q1}|jtdkrjd}nH|jtdkrddddg|j t}nt d t |t rt d njd d krd jdj|jdt|jkrdndd|rDddjtfd|ndd|dt|jkrednddj|j}|dkr|dj|7}qnQt|jks|rt dndjtfd|j|jg}|S(Nt dimensioniRsis , intent(%s)tintouttinouts!Multiple intents specified for %ss1Pointers are not available by default in Fortran.RTiZs"{t}{vc}{dim}{intent}{alloc} :: {s}Rtvcs , parameterRs, dimension(%s)s, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRstintenttallocs , allocatabletss = %ss0F77 init./parameter statem. req. multiple lines.t c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(tvariableRt attr_paramsRRR tattrstcountRvtindexRhRRRRgRRttypeRRRRRR(RkR|RtvalRRtintentstresult((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Declarations2  + # 1 -cC sd|jtdS(Ns(huge(%s) + 1)i(RR(RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Infinitysc s"dj|jdfdS(Ns$do while ({condition}) {body} end doRc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RR(RkR|((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_WhilescC sdS(Ns.true.((RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_BooleanTruescC sdS(Ns.false.((RkR|((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_BooleanFalsescC sgg}xZ|D]R}|jdrG|j|jd|djq |j|jd|q W|S(Nt!RqiRo(RRyRttlstrip(RkRR'tline((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_pad_leading_columnss  %c sdtdtjtjtdfd}g}|jddkrZd}nd}x|D]}|j|jdrzt|d krj|jd d d }|d krd }n|| }||j }|j |x|rf|jd d d}|d ks"t|dkr+d}n|| }||j }|j d|jd|fqWq\|j |qg|j|jdrO||d }|| j }||j }|r||7}n|j |xz|rK||d}|| j }||j }|r*||7}n|j d|jd|fqWqg|j |qgW|S(sWrap long Fortran lines Argument: lines -- a list of lines (without \n character) A comment line is split at white space. Code lines are split with a more complex rule to give nice results. s_+-.s ()c sht|krtS|}fd}x*||sc|d8}|dkr:|Sq:W|S(Nc s|kr$|dkp|krH|dkp|krl|dkp|ko|dkS(Ni((tpos(R/tmy_alnumtmy_white(s3lib/python2.7/site-packages/sympy/printing/fcode.pyR s$$$ii(R(R/tendposR1tsplit(R2R3(R/s3lib/python2.7/site-packages/sympy/printing/fcode.pytsplit_pos_codes   RRRrs &RsRqiHRiiiiBs%s%sRoiARp( Ritstringtdigitst ascii_lettersRgRRtRtrfindR.RyR(RkRR6R'ttrailingR/R1thunk((R2R3s3lib/python2.7/site-packages/sympy/printing/fcode.pyRsP           %    %cC s#t|tr4|j|jt}dj|S|jddk}g|D]}|jd^qN}d}d}g|D]$}tt t |j |^q|}g|D]$}tt t |j |^q}g|D]*}tt t |j ddg^q} d} d} d} g} xt |D]\}}|dksW|dkrj| j|q3n| ||8} |rd| | | }nd| | }d||f}|s|j|gd}n| j|| |rd| } nd} | ||7} q3W|s|j| S| S(s0Accepts a string of code or a list of code linesRsRRRrs sdo sif(sif sdo Rtprogramt interfacesend dotenddosend iftendifs end programs end interfacet&s& iis Rs%s%si(sdo sif(sif sdo RR=R>(send doR?send ifR@Rs end programs end interface(RR&Rt splitlinesRvRRgR.RtanyRRtendswithRRyR0R(RkRot code_linesRrR/t inc_keywordt dec_keywordtincreasetdecreaset continuationtlevelt cont_paddingttabwidthtnew_codeRtpadding((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRBsH "..4     c sj|jrIdjddjtfd|jdj|jS|j\}dj|SdS(Nsgo to ({labels}), {expr}tlabelss, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRwRsR|sgo to %s(R|RRRRPR(Rktgototlbl((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_GoTots   $ c s"dj|jdfdS(Ns"program {name} {body} end program Rc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RR(Rktprog((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Program~sc s"dj|jdfdS(NsAmodule {name} {declarations} contains {definitions} end module Rc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RR(Rktmod((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_ModulescC s|jdkr:|jddkr:|jdjddS|jdkrt|jddkrt|jdjdd S|jdkrd S|jSdS( NtstdoutRTiRIsstdint=>input_unitt input_unittstderrsstdint=>error_unitt error_unitt*(RwRgRjR(Rktstrm((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Streams""c s^|jdkr$j|j}nd}djd|ddjtfd|jS(NR\sprint {fmt}, {iolist}tfmttiolists, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(t format_stringRRRRRt print_args(RktpsR_((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Prints cC s:|j\}djd|jjddd|j|S(Ns{result_name} = {arg}t result_namet sympy_resultR(RRt_contextReR(RktrsR((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_Returns  cC s+|j\}|r#d|j|SdSdS(Ns return %streturn(RR(RktfrsR((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_FortranReturns c s|jd}|dkr$d}n|r8d|dnd}jjdd}djd|d j|jd d jg|jD]}j|j ^qd |rd |ndd|ddjt fd|jS(Ntbind_CRss bind(C, name="%s")is bind(C)Res<{entity}{name}({arg_names}){result}{bind} {arg_declarations}tentityRwt arg_namess, R's result(%s)tbindtarg_declarationss c sjt|S(N(RR(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs( R RRgReRRRwRt parametersRR(RkRntfpRt bind_C_paramsRpReR((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_heads   1cC s7dj|j|j}djd|j||S(Ns {0} function s4interface {function_head} end function end interfacet function_head(RRt return_typeRu(RkRsRn((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_FunctionPrototypes c C st|jkrd}nt|jkr0d}nd}dj|j|j}t|d|j9djd|d|j||d |j|j SWdQXdS( Ns elemental spure Rss {0} function Res,{prefix}{function_head} {body} end function tprefixRvR( RR!RRRRwR.RwRuR(RktfdRyRn((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_FunctionDefinitions   cC s.djd|jd|d|j|jS(Ns({subroutine_head} {body} end subroutine tsubroutine_heads subroutine R(RRuRR(Rktsub((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_Subroutines c s@djdj|jddjtfd|jS(Nscall {name}({args})RwRs, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RRRwRRtsubroutine_args(Rktscall((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_SubroutineCalls c s#dttfd|jS(Ns%s => %sc s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(ttupleRR(Rktrnm((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_use_renamescC sd|j|j}|jdkr^|ddjg|jD]}|j|^q;7}n|jdkr|ddjg|jD]}|j|^q7}n|S(Nsuse %ss, s, only: (Rt namespacetrenameRRtonly(RktuseR'Rtnly((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt _print_uses 99cC sdS(Ntexit((RkRu((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_BreakTokenscC sdS(Ntcycle((RkRu((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_ContinueTokensc sEjddkrdnd}|djtfd|jS(NRTis[%s]s(/%s/)s, c s j|S(N(R(R(Rk(s3lib/python2.7/site-packages/sympy/printing/fcode.pyRRs(RgRRtelements(Rktactfmtstr((Rks3lib/python2.7/site-packages/sympy/printing/fcode.pyt_print_ArrayConstructorsN(ZRt __module__t__doc__t printmethodtlanguageRRR RR RR[RRR R R RRRR\R RRvtFalset_default_settingst _operatorst _relationalsRctpropertyRtR{R~RRRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRR(R)R*R+R,R0RRRSRURWR^RdRiRlRuRxR{R~RRRRRR(((s3lib/python2.7/site-packages/sympy/printing/fcode.pyRDBs               *  '                 !     G 2           cK st|j||S(sHConverts an expr to a string of fortran 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 is helpful in case of line-wrapping, or for expressions that generate multi-line statements. precision : integer, optional DEPRECATED. Use type_mappings instead. The precision for numbers such as pi [default=17]. 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]. source_format : optional The source format can be either 'fixed' or 'free'. [default='fixed'] standard : integer, optional The Fortran standard to be followed. This is specified as an integer. Acceptable standards are 66, 77, 90, 95, 2003, and 2008. Default is 77. Note that currently the only distinction internally is between standards before 95, and those 95 and after. This may change later as more features are added. name_mangling : bool, optional If True, then the variables that would become identical in case-insensitive Fortran are mangled by appending different number of ``_`` at the end. If False, SymPy won't interfere with naming of variables. [default=True] Examples ======== >>> from sympy import fcode, symbols, Rational, sin, ceiling, floor >>> x, tau = symbols("x, tau") >>> fcode((2*tau)**Rational(7, 2)) ' 8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)' >>> fcode(sin(x), assign_to="s") ' s = 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)]. >>> custom_functions = { ... "ceiling": "CEIL", ... "floor": [(lambda x: not x.is_integer, "FLOOR1"), ... (lambda x: x.is_integer, "FLOOR2")] ... } >>> fcode(floor(x) + ceiling(x), user_functions=custom_functions) ' CEIL(x) + FLOOR1(x)' ``Piecewise`` expressions are converted into conditionals. If an ``assign_to`` variable is provided an if statement is created, otherwise the ternary operator is used. 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 >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(fcode(expr, tau)) if (x > 0) then tau = x + 1 else tau = x end if 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])) >>> fcode(e.rhs, assign_to=e.lhs, contract=False) ' Dy(i) = (y(i + 1) - y(i))/(t(i + 1) - t(i))' Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions must be provided to ``assign_to``. Note that any expression that can be generated normally can also exist inside a Matrix: >>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(fcode(mat, A)) A(1, 1) = x**2 if (x > 0) then A(2, 1) = x + 1 else A(2, 1) = x end if A(3, 1) = sin(x) (RDtdoprint(R|t assign_toRl((s3lib/python2.7/site-packages/sympy/printing/fcode.pytfcodesucK stt||dS(s|Prints the Fortran representation of the given expression. See fcode for the meaning of the optional arguments. N(tprintR(R|Rl((s3lib/python2.7/site-packages/sympy/printing/fcode.pyt print_fcodes(CRt __future__RRt collectionsRt itertoolsRR7tsympy.codegen.astRRRRRR R R R R RRRRRRRRtsympy.codegen.fnodesRRRRRRRRRRR t sympy.coreR!R"R#R$R%tsympy.core.compatibilityR&R'tsympy.core.functionR(tsympy.core.relationalR)t sympy.setsR*tsympy.printing.codeprinterR+tsympy.printing.precedenceR,R-tsympy.printing.printerR.RdRDRRR(((s3lib/python2.7/site-packages/sympy/printing/fcode.pytsJ vL(  x