\h? SrSSKrSSKrSSKJr SSKJr SSKJ r J r J r J r J r Jr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJrJrJr SS KJ r J!r!J"r"J#r#J$r$ SSK%J&r& /SQr'"SS5r("SS5r)\)"SSSSSS5\)"SSSSSS5\)"SSSSSS5S.r*Sr+SGS jr,"S!S"5r-"S#S$\-5r."S%S&\.5r/"S'S(5r0"S)S*\.\05r1"S+S,\.\05r2"S-S.\-\05r3"S/S05r4"S1S2\55r6"S3S4\55r7S5r8"S6S7\45r9"S8S9\95r:"S:S;\95r;"S<S=\45r<"S>S?\45r="S@SA\45r>"SBSC\45r?SHSDjr@SISEjrASJSFjrBg)Ka% module for generating C, C++, Fortran77, Fortran90, Julia, Rust and Octave/Matlab routines that evaluate SymPy expressions. This module is work in progress. Only the milestones with a '+' character in the list below have been completed. --- How is sympy.utilities.codegen different from sympy.printing.ccode? --- We considered the idea to extend the printing routines for SymPy functions in such a way that it prints complete compilable code, but this leads to a few unsurmountable issues that can only be tackled with dedicated code generator: - For C, one needs both a code and a header file, while the printing routines generate just one string. This code generator can be extended to support .pyf files for f2py. - SymPy functions are not concerned with programming-technical issues, such as input, output and input-output arguments. Other examples are contiguous or non-contiguous arrays, including headers of other libraries such as gsl or others. - It is highly interesting to evaluate several SymPy functions in one C routine, eventually sharing common intermediate results with the help of the cse routine. This is more than just printing. - From the programming perspective, expressions with constants should be evaluated in the code generator as much as possible. This is different for printing. --- Basic assumptions --- * A generic Routine data structure describes the routine that must be translated into C/Fortran/... code. This data structure covers all features present in one or more of the supported languages. * Descendants from the CodeGen class transform multiple Routine instances into compilable code. Each derived class translates into a specific language. * In many cases, one wants a simple workflow. The friendly functions in the last part are a simple api on top of the Routine/CodeGen stuff. They are easier to use, but are less powerful. --- Milestones --- + First working version with scalar input arguments, generating C code, tests + Friendly functions that are easier to use than the rigorous Routine/CodeGen workflow. + Integer and Real numbers as input and output + Output arguments + InputOutput arguments + Sort input/output arguments properly + Contiguous array arguments (numpy matrices) + Also generate .pyf code for f2py (in autowrap module) + Isolate constants and evaluate them beforehand in double precision + Fortran 90 + Octave/Matlab - Common Subexpression Elimination - User defined comments in the generated code - Optional extra include lines for libraries/objects that can eval special functions - Test other C compilers and libraries: gcc, tcc, libtcc, gcc+gsl, ... - Contiguous array arguments (SymPy matrices) - Non-contiguous array arguments (SymPy matrices) - ccode must raise an error when it encounters something that cannot be translated into c. ccode(integrate(sin(x)/x, x)) does not make sense. - Complex numbers as input and output - A default complex datatype - Include extra information in the header: date, user, hostname, sha1 hash, ... - Fortran 77 - C++ - Python - Julia - Rust - ... N)StringIO) __version__)SymbolSTupleEqualityFunctionBasic)c_code_printers)AssignmentError) FCodePrinter)JuliaCodePrinter)OctaveCodePrinter)RustCodePrinter)IdxIndexed IndexedBase) MatrixSymbolImmutableMatrix MatrixBase MatrixExpr MatrixSlice) is_sequence)RoutineDataTypedefault_datatypesget_default_datatypeArgument InputArgumentOutputArgumentResultCodeGenCCodeGenFCodeGen JuliaCodeGen OctaveCodeGen RustCodeGencodegen make_routinecH\rSrSrSrSrSr\r\S5r \S5r Sr g) ruaGeneric description of evaluation routine for set of expressions. A CodeGen class can translate instances of this class into code in a particular language. The routine specification covers all the features present in these languages. The CodeGen part must raise an exception when certain features are not present in the target language. For example, multiple return values are possible in Python, but not in C or Fortran. Another example: Fortran and Python support complex numbers, while C does not. c [5n[5nUGHn[U[5(aGURURR URR [5- 5 M`[U[5(aURUR5 M[U[5(acURUR5 URURR URR [5- 5 GM [SU-5e UHkn [U [5(d[SU -5eURU RR U RR [5- 5 Mm [5n UHn [U [5(abURU RR U RR [5- 5 U RU R5 MzU RU 5 M UV s1sH&n [U [5(a U ROU iM( nn UR!UR#U 5R#U55n U [5:wa7[SSR%U V s/sHn ['U 5PM sn 5-5eXl X lX0lX@lXPlgs sn fs sn f)aYInitialize a Routine instance. Parameters ========== name : string Name of the routine. arguments : list of Arguments These are things that appear in arguments of a routine, often appearing on the right-hand side of a function call. These are commonly InputArguments but in some languages, they can also be OutputArguments or InOutArguments (e.g., pass-by-reference in C code). results : list of Results These are the return values of the routine, often appearing on the left-hand side of a function call. The difference between Results and OutputArguments and when you should use each is language-specific. local_vars : list of Results These are variables that will be defined at the beginning of the function. global_vars : list of Symbols Variables which will not be passed into the function. zUnknown Routine argument: %szUnknown Routine result: %sz+Symbols needed for output are not in input , N)set isinstancer updateexpr free_symbolsatomsrraddname InOutArgument ValueErrorr!rlabel differenceunionjoinstr argumentsresults local_vars global_vars)selfr5r=r>r?r@ input_symbolssymbolsargr local_symbolss notcoveredxs O/var/www/auris/envauris/lib/python3.13/site-packages/sympy/utilities/codegen.py__init__Routine.__init__sE@ %C#~..sxx44sxx~~g7NNOC//!!#((+C//!!#((+sxx44sxx~~g7NNO !?#!EFFAa(( !=!ABB NN166..g1FF G  A!V$$qvv22QVV\\'5JJK!!!&&)!!!$ BIIAjC00177a7I ''    . 4 4[ AC  J!YY 'C 1A 'CDEF F " $&J(Ds -LLchURRSR"S0URD6-$)Nz?({name!r}, {arguments}, {results}, {local_vars}, {global_vars})) __class____name__format__dict__rAs rJ__str__Routine.__str__sA~~&&)j)q)q*CtxuBuB*CC Cc[UR5nURSUR55 URSUR55 U$)zReturns a set of all variables possibly used in the routine. For routines with unnamed return values, the dummies that may or may not be used will be included in the set. c38# UHoRv M g7fNr5).0rDs rJ $Routine.variables..s4^c^c38# UHoRv M g7frY) result_var)r[ress rJr\r]s8)rAvs rJ variablesRoutine.variablessC   4T^^44 84<<88rVcURVs/sH"n[U[[45(dM UPM$ nnUR UR 5 U$s snf)z|Returns a list of OutputArgument, InOutArgument and Result. If return values are present, they are at the end of the list. )r=r/r r6extendr>)rArDargss rJresult_variablesRoutine.result_variablessK $~~3~ .-022~3 DLL! 3s AA)r=r@r?r5r>N) rP __module__ __qualname____firstlineno____doc__rKrT__repr__propertyrcrh__static_attributes__rNrVrJrrusA I'VCH   rVrc\rSrSrSrSrSrg)rz? ? jeT]CCFH H ~~__&&ooOO  %"rVcRURR<SUR<S3$)N())rOrPr5rSs rJrTVariable.__str__Js>>22DII>>rVcUR$rY)rrSs rJr5 Variable.nameOs zzrVcURUR5$![a( [SSR UR5-5ef=f)aReturns the datatype string for the requested language. Examples ======== >>> from sympy import Symbol >>> from sympy.utilities.codegen import Variable >>> x = Variable(Symbol('x')) >>> x.get_datatype('c') 'double' >>> x.get_datatype('fortran') 'REAL*8' zHas datatypes for languages: %sr-)rupperKeyError CodeGenErrorr;)rAlanguages rJ get_datatypeVariable.get_datatypeSsQ />>(.."23 3 /@IIdnn- ./ / /s 2A)rrrrNNN) rPrjrkrlrmrKrTrnror5rrprNrVrJrrs.&*#X?H /rVrc\rSrSrSrSrg)riizsAn abstract Argument data structure: a name and a data type. This structure is refined in the descendants below. rNN)rPrjrkrlrmrprNrVrJrris   rVrc\rSrSrSrg)rirrNNrPrjrkrlrprNrVrJrrrrVrc(\rSrSrSrSrSr\rSrg) ResultBaseivzBase class for all "outgoing" information from a routine. Objects of this class stores a SymPy expression, and a SymPy object representing a result variable that will be used in the generated code only if necessary. cXlX lgrYr1r`)rAr1r`s rJrKResultBase.__init__~s  $rVcnURR<SUR<SUR<S3$Nrr-r)rOrPr1r`rSs rJrTResultBase.__str__s&#~~66 OO rVrN rPrjrkrlrmrKrTrnrprNrVrJrrvs%HrVrc,\rSrSrSrSSjrSr\rSrg)r iz5OutputArgument are always initialized in the routine.Nc^[RXXEU5 [RXU5 g)aReturn a new variable. Parameters ========== name : Symbol, MatrixSymbol The name of this variable. When used for code generation, this might appear, for example, in the prototype of function in the argument list. result_var : Symbol, Indexed Something that can be used to assign a value to this variable. Typically the same as `name` but for Indexed this should be e.g., "y[i]" whereas `name` should be the Symbol "y". expr : object The expression that should be output, typically a SymPy expression. datatype : optional When not given, the data type will be guessed based on the assumptions on the symbol argument. dimensions : sequence containing tuples, optional If present, the argument is interpreted as an array, where this sequence of tuples specifies (lower, upper) bounds for each index of the array. precision : int, optional Controls the precision of floating point constants. N)rrKrrAr5r`r1rrrs rJrKOutputArgument.__init__s'D $hIFD 3rVcURR<SUR<SUR<SUR<S3$r)rOrPr5r`r1rSs rJrTOutputArgument.__str__s*#'>>#:#:DIItX\XaXabbrVrNrrrNrVrJr r s?#4JcHrVr cb\rSrSrSrSSjr\R R\lSr\rSr g)r6iz3InOutArgument are never initialized in the routine.NcU(d [U5n[RXXEU5 [RXU5 grY)rrrKrrs rJrKInOutArgument.__init__s1+D1H$hIFD 3rVcURR<SUR<SUR<SUR<S3$r)rOrPr5r1r`rSs rJrTInOutArgument.__str__,#'>>#:#:DIItyy OO rVrNr) rPrjrkrlrmrKr rTrnrprNrVrJr6r6s,=4 &..66HHrVr6c0\rSrSrSrSSjrSr\rSrg)r!ia%An expression for a return value. The name result is used to avoid conflicts with the reserved word "return" in the Python language. It is also shorter than ReturnValue. These may or may not need a name in the destination (e.g., "return(x*y)" might return a value without ever naming it). Nc[U[[45(d [S5eUcS[ [ U55-nUc [ U5n[U[5(a=[U[[45(a[U/URQ76nO [U5nUcUn[RXUXVS9 [RXU5 g)aInitialize a return value. Parameters ========== expr : SymPy expression name : Symbol, MatrixSymbol, optional The name of this return variable. When used for code generation, this might appear, for example, in the prototype of function in a list of return values. A dummy name is generated if omitted. result_var : Symbol, Indexed, optional Something that can be used to assign a value to this variable. Typically the same as `name` but for Indexed this should be e.g., "y[i]" whereas `name` should be the Symbol "y". Defaults to `name` if omitted. datatype : optional When not given, the data type will be guessed based on the assumptions on the expr argument. dimensions : sequence containing tuples, optional If present, this variable is interpreted as an array, where this sequence of tuples specifies (lower, upper) bounds for each index of the array. precision : int, optional Controls the precision of floating point constants. z.The first argument must be a SymPy expression.Nz result_%d)rrr)r/r rrabshashrr<rrshaperrrKr)rAr1r5r`rrrs rJrKResult.__init__sD$ 344LM M <T$Z0D  +D1H dC $Z 899#D64::6d|  J$x%/  FD 3rVcURR<SUR<SUR<SUR<S3$r)rOrPr1r5r`rSs rJrTResult.__str__ rrVrN)NNNNNrrNrVrJr!r!s#CG,074rHrVr!cZ\rSrSrSrSrSrS SjrSrS Sjr SSjr SS jr SS jr S r g)r"iz'Abstract class for the code generators.Nc8URRU5$rY)printer indent_coderA codeliness rJ _indent_codeCodeGen._indent_codes||'' 22rVctU=(d 0nUVs0sHoUURRU_M nnUR5HupWXpRRU'M [URU5"U0UD6nUR5HupWXpRRU'M U$s snfrY)r _settingsitemsgetattr) rAmethodsettingsrgkwargskorirbresults rJ_printer_method_with_settings%CodeGen._printer_method_with_settings s>r5=>X$,,((++X>NN$DA()LL " "1 %%v.??IIKDA()LL " "1 %  ?s#B5c:URRS(a+URRU5nUR 5$URRU5up4nU(dU(a[S[ U5-5eUR 5$)z&Returns the symbol as fcode prints it.humanzFailed to print %s)rrdoprintr7r<strip)rArGexpr_str constants not_supporteds rJ _get_symbolCodeGen._get_symbol*sy << ! !' *||++A.H ~~261E1Ea1H .IhM !5A!>??~~rVcXlX lg)zgInitialize a code generator. Derived classes will offer more options that affect the generated code. Nprojectcse)rArrs rJrKCodeGen.__init__4s rVc @UR(GarSSKJn [U5(a[U[[ 45(dU(d [ S5eUH.nUR(aM[SRU55e UVs/sHofRPM nnU"U5up[X)5VVs/sHupg[URU5PM nnnOO[U[5(a.U"UR5up[URU S5nO U"U5upU nUV V s/sHup[X5PM n n n UV V s1sHupU iM nn n [UV V s/sHupU PM sn n 6nO [5n[U5(a6[U[[ 45(dU(d [ S5e[U6nO [U5nUR(aHUR!["5Vs1sHnUR$iM sn['5:wa [S5eO1UR!["5Vs1sHnUR$iM n nU nUc ['5O ['U5nUR(UR(-W- U- n['5nUR+U5 UHyn[U["5(a9UR-U5 UR+UR.SR(5 [U[05(dMhUR-U5 M{ Un/n/nUGH.n[U[5(Ga]URnURn[U[05(aP[3UR4Vs/sHn[6R8US- 4PM sn5nUR:R$nOv[U[<5(a/nUnO\[U[>5(a<[3UR4Vs/sHn[6R8US- 4PM sn5nUnO [S5eURAU5(aURC[EUUUUS95 OURC[GUUUUS95 UW ;aUR-U5 GMtGMw[U[H[J45(a[?S [M[OU55-/UR4Q76n[3UR4Vs/sHn[6R8US- 4PM sn5nURC[GUUUUS95 GMURC[U55 GM1 /nS n0nUR![05UR![05-HnUUUR:R$'M UR![>5UR![>5-HnUUU'M [QU[RS 9H6nUU;aUUnS U"U50nO0nURC[UU40UD65 M8 URWS S 9 URYU5 UGb /nUHFn [U [Z5(aURCU R$5 M5URCU 5 MH UnUV!s/sHn!U!R\U;dMU!PM n"n!U"(aRSn#U#RSR_U"V$s/sHn$[SU$R\5PM sn$55n#[aU#U"5eUV!s0sHn!U!R\U!_M n%n!/n&UHnU&RCU%U5 M U&n[eUUUW U5$s snfs snnfs sn n fs sn n fs sn n fs snfs snfs snfs snfs snfs sn!fs sn$fs sn!f![baG [U[Z[>45(a S U"U50nO0nU&RC[UU40UD65 Mf=f)a)Creates an Routine object that is appropriate for this language. This implementation is appropriate for at least C/Fortran. Subclasses can override this if necessary. Here, we assume at most one return value (the l-value) which must be scalar. Additional outputs are OutputArguments (e.g., pointers on right-hand-side or pass-by-reference). Matrices are always returned via OutputArguments. If ``argument_sequence`` is None, arguments will be ordered alphabetically, but with all InputArguments first, and then OutputArgument and InOutArguments. r)rNo expression givenz7Lists of expressions must all be Equalities. {} is not.z9CSE and Indexed expressions do not play well together yetBOnly Indexed, Symbol, or MatrixSymbol can define output arguments.rzout_%sclURVs/sHn[RUS- 4PM sn$s snfNr)rrZero)rGdims rJr#CodeGen.routine..dimensionss+129#QVVS1W%9 99s1keyrc,[UR5$rYr<r5rIs rJ!CodeGen.routine.. s166{rV"Argument list didn't specify: {0} r-)3rsympy.simplify.cse_mainrr/rrr7 is_EqualityrrQrhsziprlhsr!rr3rr8r.r2r0removergrrrrrbaserrhasappendr6r rrrrsortedr<rsortrfrr5r;CodeGenArgumentListErrorrr)'rAr5r1argument_sequencer@rercommon simplifiedabr?_rFlocal_expressions expressionsirC new_symbolssymbol return_val output_argsout_argrdimsarg_listr array_symbolsarraymetadata new_sequencerDrImissingmsgm name_arg_dictnew_argss' rJroutineCodeGen.routine>s 888 34  D:z:R)S)S$%:;;A===*+d+k+klm+noo '++duud+%(X"#>#>?&'**""6*    D$))((xxgw//  !N AFFC!G#4 !NOD$\\//F00D$F66  !N AFFC!G#4 !NOD$F&(FGG88F##&&%fgtMO &&&vwNP+NN6*,D?K"@AA&x#d4j/'AODJJO7==I=CqvvsQw/=IJ"""7GTdKM!!&,/G J  :  &&w/2C2I2I'2RRE.3M%**** +S &&|47H7N7N|7\\E#(M% ]W#.F&%f-(*U*;< OOM&=H= >/ 23 $  (L(c;// '' 2 '', ) !- "*N(Qaff ) M)(s B,, B; cURU5nUGH nU(aURS5 URURU55 URUR U55 URUR U55 URUR U55 U(aURS5 URURU55 U(aURS5 URURU55 GM URSRU55nU(a#SRUR5U/-5nU(aURU5 gg)aWrite the code by calling language specific methods. The generated file contains all the definitions of the routines in low-level code and refers to the header file if appropriate. Parameters ========== routines : list A list of Routine instances. f : file-like Where to write the file. prefix : string The filename prefix, used to refer to the proper header file. Only the basename of the prefix is used. header : bool, optional When True, a header comment is included on top of each source file. [default : True] empty : bool, optional When True, empty lines are included to structure the source files. [default : True]  r|N) _preprocessor_statementsrrf_get_routine_opening_declare_arguments_declare_globals_declare_locals _call_printer_get_routine_endingrr; _get_headerr8)rAr/r6r0r2r3 code_linesr&s rJ dump_codeCodeGen.dump_codes7:226: G!!$'   d77@ A   d55g> ?   d33G< =   d227; <!!$'   d009 :!!$'   d66w? @ &&rwwz':; !1!1!3zl!BCJ  GGJ  rV)rrrY)rF)NN)FTTTT)rPrjrkrlrmrrrrrKr&r8rErprNrVrJr"r"s11G3 lL\)V3 rVr"c\rSrSrSrg)riMrNNrrNrVrJrrMrrVrc$\rSrSr\S5rSrg)r iQc URS$r)rgrSs rJ missing_args%CodeGenArgumentListError.missing_argsRsyy|rVrNN)rPrjrkrlrorKrprNrVrJr r Qs rVr z{Code generated with SymPy %(version)s See http://www.sympy.org/ for more information. This file is part of '%(project)s' c^\rSrSrSrSrSrSrSU4SjjrSr Sr S r S r S r S rS rSrSrSSjr\\l\R*R\lSSjr\\l\\/rSrU=r$)r#i_zGenerator for C code. The .write() method inherited from CodeGen will output a code file and an interface file, .c and .h respectively. chc99c>[TU]XS9 U=(d& [URR 5"5UlX0lUc S/Ulgg)Nrz#include )superrKr standardlowerrpreprocessor_statements)rArrrUrrOs rJrKCCodeGen.__init__ksP 2J/$--2E2E2G"H"J '>$ " *,?+@D ( +rVc/nURS5 [[URS.-nUR 5H&nURSUR S5-5 M( URS5 U$)/Writes a common header for the generated files.zP/****************************************************************************** versionrz *%s* LzQ ******************************************************************************/ rheader_comment sympy_versionr splitlinescenterrArDtmplines rJrCCCodeGen._get_headertso -.=+/<< 99NN$D   i$++b/9 :%./rVc[UR5S:a [S5e[UR5S:XaURSRS5nOSn/nURHnUR R UR5nUR(d[U[5(a'URURS5SU-45 MuURURS5U45 M SRUVs/sHnSU-PM sn5nU<S UR<S U<S 3$s snf) Returns a string for the function prototype of the routine. If the routine has multiple result objects, an CodeGenError is raised. See: https://en.wikipedia.org/wiki/Function_prototype rz,C only supports a single or no return value.rrvoid*%sr-z%s %s rr) lenr>rrr=rrr5rr/rrr;)rAr&ctype type_argsrDr5tr=s rJ get_prototypeCCodeGen.get_prototypes  w ! #MN N  !Q &OOA&33C8EE $$C<<''1D~~C!? % IIY?Y! Y?@ #W\\9==@sEc/nURSR[RR U555 UR UR 5 UVs/sHnSRU5PM nnU$s snf)Nz#include "{}.h"z{} )rrQospathbasenamerfrU)rAr0rDls rJr<!CCodeGen._preprocessor_statementssl +222773C3CF3KLM$6670:; 1fmmA& ;c0URU5nSU-/$Nz%s { rnrAr& prototypes rJr=CCodeGen._get_routine_opening &&w/ 9$%%rVc/$rYrNrAr&s rJr>CCodeGen._declare_arguments rVc/$rYrNr~s rJr?CCodeGen._declare_globalsrrVc /nURHHn[U[5(dMUR(aM-UR UR 5 MJ /nUR GHcn[U[5(dMUR UR:wa[SRU55eUR nURS5n[UR[[45(aMURRnUR SRU[!U5USUS-55 Sn OSRU5n UR#SS US S .URUS 9upn [%U [ S 9HupUR S U <SU<S35 M! UR SRX55 GMf U$)Nz)Result variable and name should match: {}rNz {} {}[{}]; rrr|z const {} rFr dereferencestrict assign_tor double const  = ; z{}{} )r=r/rrrr5r?r!r`r"rQrr1rrrr<rr )rAr&rrDrDrrrmrr0rnot_cc_exprr5values rJr@CCodeGen._declare_localss  $$C#z**3>>>""388,% ((Fff--{{f///IPPQWXYY I##C(A&++ J'?@@{{((!!."7"73y>4PQ7SWXYSZ?"[\$++A.'+'I'IU;RWX y(J(2 $If &iS9 !!tU"KL :   hoof= >3)6rVc /n/nURHHn[U[5(dMUR(aM-UR UR 5 MJ SnUR Hn[U[5(aMUR S-nURS5nUR SRU[U555 UnO URnURSSUSS.URUS9upn [U [S 9HupUR S U <S U <S 35 M! UR S U -5 M U(aUR SU-5 U$![ac URnUR URS5<S[U5<S 35 URSSUSS.URUS9upn Nf=f)N_resultrNz{} {}; rFrrrirrrr%s z return %s; )r=r/rrrr5rhr!rrQr<r`rr1r r )rAr&rDrrDrrrrmrrrr5rs rJrACCodeGen._call_printers  $$C#z**3>>>""388,% ..F&&))#LL94 '',!!*"3"3As9~"FG& "--  6+/+M+M{V[\KK9,N,6( & &iS9 !!tU"KL :   fvo .//2    /*< =# 6"-- !!"("5"5c":C NKM+/+M+M{V[\KK9,N,6( &  6s#E&&A*GGcS/$Nz} rNr~s rJrBCCodeGen._get_routine_ending wrVc*URXX4U5 grYrErAr/r6r0r2r3s rJdump_cCCodeGen.dump_c xFE:rVcU(a'[SRUR55US9 URR SS5R 5<SUR SS5R 5<S3nU(a [US9 [SU-US9 [S U-US9 U(a [US9 UH!nUR U5n[S U-US9 M# U(a [US9 [S US9 U(a [US9 g g ) a,Writes the C header file. This file contains all the function declarations. Parameters ========== routines : list A list of Routine instances. f : file-like Where to write the file. prefix : string The filename prefix, used to construct the include guards. Only the basename of the prefix is used. header : bool, optional When True, a header comment is included on top of each source file. [default : True] empty : bool, optional When True, empty lines are included to structure the source files. [default : True] r|filerir__/__Hz #ifndef %sz #define %sz%s;z#endifN)printr;rCrreplacerrn) rAr/r6r0r2r3 guard_namer&rzs rJdump_hCCodeGen.dump_hs6  "''$**,-A 6$(LL$8$8 %eg%%~~c37==?A   qM lZ'a0 lZ'a0  qMG**73I %)#! ,   qM hQ  qM rV)rUr)rNNFrG)rPrjrkrlrmcode_extensioninterface_extensionrSrKrCrnr<r=r>r?r@rArBrr,r"rErr+rp __classcell__rOs@rJr#r#_sNH2638A >4&&P'R;%F&&..FN/`+FHrVr#c\rSrSrSrSrg) C89CodeGeni;C89rNNrPrjrkrlrSrprNrVrJrr;HrVrc\rSrSrSrSrg) C99CodeGeni>C99rNNrrNrVrJrr>rrVrc^\rSrSrSrSrSrSU4SjjrSrSr Sr S r S r S r S rS rSrSrSSjr\\l\R*R\lSSjr\\l\\/rSrU=r$)r$iAzGenerator for Fortran 95 code The .write() method inherited from CodeGen will output a code file and an interface file, .f90 and .h respectively. f90rOcT>[TU]U5 U=(d [5UlgrY)rRrKr rrArrrOs rJrKFCodeGen.__init__Ls !0,. rVc/nURS5 [[URS.-nUR 5H&nURSUR S5-5 M( URS5 U$)rXzP!****************************************************************************** rYz!*%s* r[r\ras rJrCFCodeGen._get_headerPso -.=|| %%NN$D   i$++b/9 :%-.rVc/$rYrNrAr0s rJr<!FCodeGen._preprocessor_statements[ rVcd^/n[UR5S:a [S5e[UR5S:XaAURSnURUR S55 URS5 OURS5 SR U4SjUR 55nS RURU5nS R [R"US S S 95S-nURU5 SR U5/nURS5 U$)z6Returns the opening statements of the fortran routine.rz2Fortran only supports a single or no return value.rfortranfunction subroutiner-c3`># UH#nSTRUR5-v M% g7f)%sN)rr5)r[rDrAs rJr\0FCodeGen._get_routine_opening..ks,6#4C 0 0 ::#4s+.z{}({}) z & <F)widthbreak_long_wordsr;rizimplicit none ) rjr>rrrr;r=rQr5textwrapwrap)rAr& code_listrrgcall_sigs` rJr=FCodeGen._get_routine_opening^s w ! #DF F  !Q &__Q'F   V00; <   Z (   \ *yy6#*#4#466$$W\\48;;x}}X35>C EFHLM "XXi() *+rVc >/n/n/nURGH^n[U[5(aSURS5-nOk[U[5(aSURS5-nOA[U[ 5(aSURS5-nO[ S[U5-5eURnUR(aSRURVs/sH$nU"USS-5<S U"USS-5<3PM& sn5n US U -- nURU<S U"UR5<S 35 GM5URU<S U"UR5<S 35 GMa URU5 URU5 U$s snf) Nz%s, intent(in)rz%s, intent(inout)z%s, intent(out)zUnknown Argument type: %sr-rr:z, dimension(%s) :: r;)r=r/rrr6r rtyperrr;rr5rf) rAr&r array_list scalar_listrDtypeinfofprintrdimstrs rJr>FCodeGen._declare_argumentsyso   $$C#}--+c.>.>y.IIC//.1A1A)1LLC00,s/?/? /JJ"#>c#JKK%%F~~"~~$/-3q6A:&s1vz(:%<-$/0-66!!(F388r~s rJrBFCodeGen._get_routine_endings% w 1 $$% %&' 'rVc S/nURURU55 URURU55 URURU55 UR S5 SR U5$)zReturns a string for the function interface. The routine should have a single result object, which can be None. If the routine has multiple result objects, a CodeGenError is raised. See: https://en.wikipedia.org/wiki/Function_prototype z interface zend interface r|)rfr=r>rBrr;rys rJ get_interfaceFCodeGen.get_interfacesu$% 227;<009:11':;*+wwy!!rVc /n/nURGH5n[U[5(a URnO'[U[[ 45(a UR nURSSSSSS.URWS9upgn[U[S9H7up[U 5n URU R<SU <S U <S 35 M9 [U[S9HUn [U 5n [U [5(a U Rn OU n URU R<S U <S 35 MW URS U-5 GM8 X#-$) NrFfree_)r source_formatrSrrrz, parameter :: rr;rr)rhr/r!r5r r6r`rr1r r<rrrur func) rAr& declarationsrDrrr not_fortranf_exprobjrbrmr5s rJrAFCodeGen._call_printers-  ..F&&))#LL F^]$CDD"-- -1-O-OUVQS_de y.P.2 *IF!4(-##45GGS!DF5ks3(-c8,,88DD##AGGT$BC 4   fvo .-/.((rVc0URSSSSS.U5$)NrFr)rrrrrs rJrFCodeGen._indent_codes&11 UVuUW`b brVc UHnURVs1sHn[U5R5iM nnURVs1sHn[U5iM n n[U5[U 5:dMu[ SSR URV s/sHn [U 5PM sn 5-5e UR XX4U5 gs snfs snfs sn f)Nz%Fortran ignores case. Got symbols: %sr-)rcr<rTrjrr;rE) rAr/r6r0r2r3rErI lowercase orig_casers rJdump_f95FCodeGen.dump_f95sA12=AQI=)*5AQI59~I."#J #D CH #DE$GHH  xFE: >5$Es#CCCcU(a'[SRUR55US9 U(a [US9 UH%nURU5nUR U5 M' U(a [US9 gg)aWrites the interface to a header file. This file contains all the function declarations. Parameters ========== routines : list A list of Routine instances. f : file-like Where to write the file. prefix : string The filename prefix. header : bool, optional When True, a header comment is included on top of each source file. [default : True] empty : bool, optional When True, empty lines are included to structure the source files. [default : True] r|rN)rr;rCrr8)rAr/r6r0r2r3r&rzs rJrFCodeGen.dump_hsd4  "''$**,-A 6  qMG**73I GGI    qM rVrrNrG)rPrjrkrlrmrrrKrCr<r=r>r?r@rBrrArrr,r"rErr+rprrs@rJr$r$AsN1 6 D ("$)8b;(H((00H#H+F&!HrVr$c^\rSrSrSrSrSU4SjjrSrSrSr Sr S r S r S r S rS rSrSSjr\\l\R(R\l\/rSrU=r$)r%izlGenerator for Julia code. The .write() method inherited from CodeGen will output a code file .jl. jlcT>[TU]U5 U=(d [5UlgrY)rRrKrrrs rJrKJuliaCodeGen.__init__"s  !4"2"4 rVc [U5(a6[U[[45(dU(d [ S5e[ U6nO [ U5nUR [5Vs1sHofRiM nnUc [5O [U5nURU- U- n[5n UHjn [U [5(a*U RU RSR5 MB[U [5(aMYU RU 5 Ml /n /n [U5GHAupb[U[ 5(GaUR"n UR$nU n[U [5(af['U R(Vs/sHn[*R,U4PM sn5nU R.RnU R1[3XUUS95 [U [[4[645(d [9S5eU R1[;X.U S95 UR=U5(dU R?U5 GMGM"U R1[;USUS--S95 GMD U RASS 9 [CU 5n0nUR [5HnUUUR.R'M UR [65HnUUU'M [EU [FS 9HnUR1[IU55 M UGb /nUHFn[U[J5(aUR1UR5 M5UR1U5 MH UnUVs/sHnURLU;dMUPM nnU(aRS nUROS RQUVs/sHn[GURL5PM sn55n[SUU5eUVs0sHnURLU_M nn/nUHnUR1UU5 M Un[WUUXU5$s snfs snfs snfs snfs snf![Ta UR1[IU55 Mlf=f) z'Specialized Routine creation for Julia.rrrrr5r`out%drZc,[UR5$rYrrs rJr&JuliaCodeGen.routine..ZrrVrrr-),rr/rrr7rr3rr8r.r2r0rgrr4 enumeraterrrrrrOnerrr6rrrr!rrr rr r<rrr5rQr;r rr)rAr5r1r r@rrr? old_symbolsrCrG return_valsrrrrrrrrr rDrIr!r"r#r$r%s rJr&JuliaCodeGen.routine&s t  Zz:6N%O%O !677,K+K(3'8'8'=>'=!gg'= > +2ceK8H "..;kI %A!S!!qvvay5567++ A   ";/IQ$))((xx gw// 7==!I=CAEE3<=!IJD$\\//F&&}VdW['\]!'GV\+JKK&(FGG""6$#PQxx''NN6*(""6$W!_#EF+00 23 $  &&w/E.3M%**** +0 &&|4E#(M% 5W#.F OOM&1 2/  (L(c;// '' 2 '', ) !- "*N(Qaff 3Q Q6Q 0Q Q$Q:9Q:c/n[[URS.-nUR5H0nUS:XaUR S5 MUR SU-5 M2 U$)rXrYr|z# z# %s r]r^rr_rras rJrCJuliaCodeGen._get_headers` =|| %%NN$Drz!!%(!!*t"34 % rVc/$rYrNrs rJr<%JuliaCodeGen._preprocessor_statementsrrVc /nURS5 /nURHn[U[5(a [ S[ [ U55-5e[U[[45(dMUURSURUR5-5 M SRU5nURUR<SU<S35 SRU5/nU$).Returns the opening statements of the routine. function z"Julia: invalid argument of type %srr-r) r|) rr=r/r rr<rrr6rr5r;)rAr&rrgrDs rJr=!JuliaCodeGen._get_routine_openings %$$C#~.."#G#&tCy>$233# }=>> D4#3#3CHH#==> % yyw||T:;ggi(* rVc/$rYrNr~s rJr>JuliaCodeGen._declare_argumentsrrVc/$rYrNr~s rJr?JuliaCodeGen._declare_globalsrrVc/$rYrNr~s rJr@JuliaCodeGen._declare_localsrrVc/nURHPn[U[5(aURUR5nO [ S5eUR U5 MR SSRU5-S-/$)N$unexpected object in Routine resultszreturn r-z end )r>r/r!rr5rrr;)rAr&outsrrGs rJrB JuliaCodeGen._get_routine_endingsjooF&&))$$V[[1"#IJJ KKN &DIIdO+i788rVc/n/nURHn[U[5(a URnO [ S5eUR SSSS.UR US9upgn[U[S9HupURU <SU <S35 M [U[S9H;n [U [5(a U Rn OU n URS U -5 M= URS U-5 M X#-$) NrrFrrrrrr;z# unsupported: %s r r>r/r!r`rrr1r r<rr r) rAr&rrDrrrrjl_exprrrbr5s rJrAJuliaCodeGen._call_printers  ooF&&))"-- "#IJJ040R0RUe ?}}Y''rVc*URXX4U5 grYrrs rJdump_jlJuliaCodeGen.dump_jlrrVrrrG)rPrjrkrlrmrrKr&rCr<r=r>r?r@rBrArr$r,r"rEr+rprrs@rJr%r%stN5YMv & 9)2( ;'G''//GOyHrVr%c^\rSrSrSrSrSU4SjjrSrSrSr Sr S r S r S r S rS rSrSSjr\\l\R(R\l\/rSrU=r$)r&iaGenerator for Octave code. The .write() method inherited from CodeGen will output a code file .m. Octave .m files usually contain one function. That function name should match the filename (``prefix``). If you pass multiple ``name_expr`` pairs, the latter ones are presumed to be private functions accessed by the primary function. You should only pass inputs to ``argument_sequence``: outputs are ordered according to their order in ``name_expr``. r#cT>[TU]U5 U=(d [5UlgrY)rRrKrrrs rJrKOctaveCodeGen.__init__s  !5"3"5 rVc [U5(a6[U[[45(dU(d [ S5e[ U6nO [ U5nUR [5Vs1sHofRiM nnUc [5O [U5nURU- U- n[5n UHjn [U [5(a*U RU RSR5 MB[U [5(aMYU RU 5 Ml /n [U5Hupb[U[ 5(aUR"n UR$nU n [U [5(aU R&Rn [U [[([*45(d [-S5eU R/[1X-U S95 UR3U 5(dU R5U 5 MMU R/[1USUS--S95 M /n0nUR [5HnUUUR&R'M UR [*5HnUUU'M [7U [8S9Hn UR/[;U 55 M UGb /nUHFn[U[<5(aUR/UR5 M5UR/U5 MH UnUVs/sHnUR>U;dMUPM nnU(aRSnURAS RCUVs/sHn[9UR>5PM sn55n[EUU5eUVs0sHnUR>U_M nn/nUHn UR/UU 5 M Un[IXXU5$s snfs snfs snfs snf![Fa UR/[;U 55 Mff=f) z(Specialized Routine creation for Octave.rrrrrrZrrr-)%rr/rrr7rr3rr8r.r2r0rgrr4rrrrrrrrrr!rrr r<rrr5rQr;r rr)rAr5r1r r@rrr?rrCrGrrrrrrr rDrIr!r"r#r$r%s rJr&OctaveCodeGen.routinesu t  Zz:6N%O%O !677,K+K(3'8'8'=>'=!gg'= > +2ceK8H "..;kI %A!S!!qvvay5567++ A  ";/IQ$))((xx gw//$\\//F!'GV\+JKK&(FGG""6$#PQxx''NN6*(""6$W!_#EF'0,  &&w/E.3M%**** +0 &&|4E#(M% 5W#.F OOM&1 2/  (L(c;// '' 2 '', ) !- "*N(Qaffr/r!rr5rrjr;r=r r6r<rr)rAr&rrrrGrgrDs rJr="OctaveCodeGen._get_routine_opening`sf %ooF&&))$$V[[1"#IJJ KKN & t9q=   SDIIdO4s: ;   RWWT] +$$C# >??"#H#&tCy>$233#}-- D4#3#3CHH#==> % yyw||T:;ggi(* rVc/$rYrNr~s rJr> OctaveCodeGen._declare_argumentsrrVc UR(d/$SR[URVs/sHo RU5PM sn55nSU-S-/$s snf)Nrizglobal r;)r@r;r r)rAr&grGs rJr?OctaveCodeGen._declare_globalss[""I HHV':M:MN:MQ--a0:MNO PA $%%OsA c/$rYrNr~s rJr@OctaveCodeGen._declare_localsrrVcS/$)Nzend rNr~s rJrB!OctaveCodeGen._get_routine_endings yrVc /n/nURHn[U[5(a URnO [ S5eUR SSSS.UR US9upgn[U[S9HupURSU <SU <S 35 M! [U[S9H;n [U [5(a U Rn OU n URS U -5 M= URS U-5 M X#-$) NrrFrrrz rz; % constant z %% unsupported: %s rr) rAr&rrDrrrroct_exprrrbr5s rJrAOctaveCodeGen._call_printers  ooF&&))"-- "#IJJ151S1SUer?r@rArBrr8) rAr/r6r0r2r3inlinerDrr&s rJdump_mOctaveCodeGen.dump_ms226: #H-JA1u%%d+   d77@ AAv<<6)$%OPP%%cFLLN&:&B'CD%%bggd.>.>.@&AB   d55g> ?   d33G< =   d227; <!!$'   d009 :!!$'   d66w? @).,&&rwwz':;  GGJ  rVrr)TTT)rPrjrkrlrmrrKr&rCr<r=r>r?r@rBrArrDr,r"rEr+rprrs@rJr&r&sw N6XMt  D& )2I @&F&&..FNxHrVr&c^\rSrSrSrSrSU4SjjrSrSrSr Sr S r S r S r S rS rSrSSjr\\l\R(R\l\/rSrU=r$)r'izjGenerator for Rust code. The .write() method inherited from CodeGen will output a code file .rs rscP>[TU]US9 U=(d [5Ulg)N)r)rRrKrrrs rJrKRustCodeGen.__init__s" )3/"3 rVc .[U5(a6[U[[45(dU(d [ S5e[ U6nO [ U5nUR [5Vs1sHofRiM nnUc [5O [U5nURU- U- UR [5- n/n /n [U5GH@upb[U[5(GaURn URnU n [U [5(ae[!U R"V s/sHn [$R&U 4PM sn 5nU R(Rn U R+[-XX.S95 [U [[.[045(d [3S5eU R+[5X,U S95 UR7U 5(dUR9U 5 GMGM!U R+[5USUS--S95 GMC U R;SS 9 [=U 5n0nUR [5HnUUUR(R'M UR [05HnUUU'M [?U[@S 9Hn UR+[CU 55 M UGb /nUHFn[U[D5(aUR+UR5 M5UR+U5 MH UnUVs/sHnURFU;dMUPM nnU(aRS nURIS RKUVs/sHn[AURF5PM sn55n[MUU5eUVs0sHnURFU_M nn/nUHn UR+UU 5 M Un[QXXU5$s snfs sn fs snfs snfs snf![Na UR+[CU 55 Mkf=f) z&Specialized Routine creation for Rust.rrrrrrrZc,[UR5$rYrrs rJr%RustCodeGen.routine..rrVrrr-))rr/rrr7rr3rr8r.r2rrrrrrrrrrrr6rrrr!rrr rr r<rrr5rQr;r rr)rAr5r1r r@rrr?rCrrrrrrrrrr rDrIr!r"r#r$r%s rJr&RustCodeGen.routines t  Zz:6N%O%O !677,K+K(3'8'8'=>'=!gg'= > +2ceK8H **Z7+E HYHYZaHbb  ";/IQ$))((xx gw// 7==!I=CAEE3<=!IJD$\\//F&&}Vd'\]!'GV\+JKK&(FGG""6$#PQxx''NN6*(""6$W!_#EF+00 23 $  &&w/E.3M%**** +0 &&|4E#(M% 5W#.F OOM&1 2/  (L(c;// '' 2 '', ) !- "*N(Qaff rz -> (r-rr|rhz%s: %szfn r) r>rrjr;r=rrr5rr/rr) rAr&rr>rstyperlrDr5rmr=s rJrnRustCodeGen.get_prototypeDs)4;??C?a>>&)?C w<1 gaj(F  !A %tyy11C7FF $$C<<''1D~~C!RustCodeGen._declare_argumentsirrVc/$rYrNr~s rJr?RustCodeGen._declare_globalsmrrVc/$rYrNr~s rJr@RustCodeGen._declare_localsqrrVc t/n/n/n/nURHHn[U[5(dMUR(aM-UR UR 5 MJ UR GH n[U[5(a1URnUR [UR55 O [S5eURSSSS.URUS9upn [U [S9HupUR SU <SU <S 35 M! [U [S9H;n[U[5(a URn OUn UR S U -5 M= UR S U -5 GM [!U5S :aS SR#U5-S-/nUR S5 X2-U-$)NrrFrrrzconst z: f64 = rz// unsupported: %s zlet %s rrr-rr;)r=r/rrrr5r>r!r`r<rrr1r r rrjr;)rAr&rDrreturnsrrDrrrrrs_exprr5rrs rJrARustCodeGen._call_printerus    $$C#z**3>>>""388,%ooF&&))"-- s6#4#456"#IJJ040R0RUer?r@rArBrfr,r"rEr+rprrs@rJr'r'svN4SMl A8 &)3V;'G''//GOyHrVr'c(US:Xa1UcO-UR5S:XaSnOUR5S:XaSn[[[[[ [ [S.RUR55nUc[SU-5eU"X5$)Nrc89rrPr)rrrF95rrrzLanguage '%s' is not supported.) rTr#rrr$r%r&r'getrr7)rrrSr CodeGenClasss rJget_code_generatorrms3    ^^  &H ^^  &H!*Z#l+')*-X^^-=)>:XEFF  ))rVc *UcU c [S5eOU b [S5e[XX5n [US[5(aU/nUcUSSn/n UH'upU R U R XUU55 M) U R XXEU5$)adGenerate source code for expressions in a given language. Parameters ========== name_expr : tuple, or list of tuples A single (name, expression) tuple or a list of (name, expression) tuples. Each tuple corresponds to a routine. If the expression is an equality (an instance of class Equality) the left hand side is considered an output argument. If expression is an iterable, then the routine will have multiple outputs. language : string, A string that indicates the source code language. This is case insensitive. Currently, 'C', 'F95' and 'Octave' are supported. 'Octave' generates code compatible with both Octave and Matlab. prefix : string, optional A prefix for the names of the files that contain the source code. Language-dependent suffixes will be appended. If omitted, the name of the first name_expr tuple is used. project : string, optional A project name, used for making unique preprocessor instructions. [default: "project"] to_files : bool, optional When True, the code will be written to one or more files with the given prefix, otherwise strings with the names and contents of these files are returned. [default: False] header : bool, optional When True, a header is written on top of each source file. [default: True] empty : bool, optional When True, empty lines are used to structure the code. [default: True] argument_sequence : iterable, optional Sequence of arguments for the routine in a preferred order. A CodeGenError is raised if required arguments are missing. Redundant arguments are used without warning. If omitted, arguments will be ordered alphabetically, but with all input arguments first, and then output or in-out arguments. global_vars : iterable, optional Sequence of global variables used by the routine. Variables listed here will not show up as function arguments. standard : string, optional code_gen : CodeGen instance, optional An instance of a CodeGen subclass. Overrides ``language``. printer : Printer instance, optional An instance of a Printer subclass. Examples ======== >>> from sympy.utilities.codegen import codegen >>> from sympy.abc import x, y, z >>> [(c_name, c_code), (h_name, c_header)] = codegen( ... ("f", x+y*z), "C89", "test", header=False, empty=False) >>> print(c_name) test.c >>> print(c_code) #include "test.h" #include double f(double x, double y, double z) { double f_result; f_result = x + y*z; return f_result; } >>> print(h_name) test.h >>> print(c_header) #ifndef PROJECT__TEST__H #define PROJECT__TEST__H double f(double x, double y, double z); #endif Another example using Equality objects to give named outputs. Here the filename (prefix) is taken from the first (name, expr) pair. >>> from sympy.abc import f, g >>> from sympy import Eq >>> [(c_name, c_code), (h_name, c_header)] = codegen( ... [("myfcn", x + y), ("fcn2", [Eq(f, 2*x), Eq(g, y)])], ... "C99", header=False, empty=False) >>> print(c_name) myfcn.c >>> print(c_code) #include "myfcn.h" #include double myfcn(double x, double y) { double myfcn_result; myfcn_result = x + y; return myfcn_result; } void fcn2(double x, double y, double *f, double *g) { (*f) = 2*x; (*g) = y; } If the generated function(s) will be part of a larger project where various global variables have been defined, the 'global_vars' option can be used to remove the specified variables from the function signature >>> from sympy.utilities.codegen import codegen >>> from sympy.abc import x, y, z >>> [(f_name, f_code), header] = codegen( ... ("f", x+y*z), "F95", header=False, empty=False, ... argument_sequence=(x, y), global_vars=(z,)) >>> print(f_code) REAL*8 function f(x, y) implicit none REAL*8, intent(in) :: x REAL*8, intent(in) :: y f = x + y*z end function z Need either language or code_genz.You cannot specify both language and code_gen.r)r7rmr/r<rr&r8) name_exprrr0rr1r2r3r r@rScode_genrr/r5r1s rJr(r(sJ  ?@ @   MN N%hK)A,$$K  ~1aH ((5F)46 7 >>(He DDrVc<[U5nURXX#5$)a A factory that makes an appropriate Routine from an expression. Parameters ========== name : string The name of this routine in the generated code. expr : expression or list/tuple of expressions A SymPy expression that the Routine instance will represent. If given a list or tuple of expressions, the routine will be considered to have multiple return values and/or output arguments. argument_sequence : list or tuple, optional List arguments for the routine in a preferred order. If omitted, the results are language dependent, for example, alphabetical order or in the same order as the given expressions. global_vars : iterable, optional Sequence of global variables used by the routine. Variables listed here will not show up as function arguments. language : string, optional Specify a target language. The Routine itself should be language-agnostic but the precise way one is created, error checking, etc depend on the language. [default: "F95"]. Notes ===== A decision about whether to use output arguments or return values is made depending on both the language and the particular mathematical expressions. For an expression of type Equality, the left hand side is typically made into an OutputArgument (or perhaps an InOutArgument if appropriate). Otherwise, typically, the calculated expression is made a return values of the routine. Examples ======== >>> from sympy.utilities.codegen import make_routine >>> from sympy.abc import x, y, f, g >>> from sympy import Eq >>> r = make_routine('test', [Eq(f, 2*x), Eq(g, x + y)]) >>> [arg.result_var for arg in r.results] [] >>> [arg.name for arg in r.arguments] [x, y, f, g] >>> [arg.name for arg in r.result_variables] [f, g] >>> r.local_vars set() Another more complicated example with a mixture of specified and automatically-assigned names. Also has Matrix output. >>> from sympy import Matrix >>> r = make_routine('fcn', [x*y, Eq(f, 1), Eq(g, x + g), Matrix([[x, 2]])]) >>> [arg.result_var for arg in r.results] # doctest: +SKIP [result_5397460570204848505] >>> [arg.expr for arg in r.results] [x*y] >>> [arg.name for arg in r.arguments] # doctest: +SKIP [x, y, f, g, out_8598435338387848786] We can examine the various arguments more closely: >>> from sympy.utilities.codegen import (InputArgument, OutputArgument, ... InOutArgument) >>> [a.name for a in r.arguments if isinstance(a, InputArgument)] [x, y] >>> [a.name for a in r.arguments if isinstance(a, OutputArgument)] # doctest: +SKIP [f, out_8598435338387848786] >>> [a.expr for a in r.arguments if isinstance(a, OutputArgument)] [1, Matrix([[x, 2]])] >>> [a.name for a in r.arguments if isinstance(a, InOutArgument)] [g] >>> [a.expr for a in r.arguments if isinstance(a, InOutArgument)] [g + x] )rmr&)r5r1r r@rrps rJr)r)ds#n"(+H   D(9 GGrVrYr) NNrFTTNNNNN)NNrj)Crmrqriorsympyrr^ sympy.corerrrrr r sympy.printing.cr sympy.printing.codeprinterr sympy.printing.fortranr sympy.printing.juliarsympy.printing.octaversympy.printing.rustr sympy.tensorrrrsympy.matricesrrrrrsympy.utilities.iterablesr__all__rrrrrrrrrr r6r!r" Exceptionrr r]r#rrr$r%r&r'rmr(r)rNrVrJrsOb .BB,6/13/22551 "ssl E;r2u = h'2r5 A, 2r7K.2K/K/\ x  H &+Xz+\Hj$HXzH^r r j  9 y Z wZ xT"wT"nF7FRrGrhV'Vv*,