\hSrSSKJr SSKJr SSKJr SSKJrJ r J r J r SSK J r JrJr SSKJr SSKJrJr SS KJrJrJr SS KJrJrJr SS KJrJrJ r J!r! S r""S S\5r#"SS\#5r$"SS\$5r%\%"5r&"SS\$5r'\'"5r("SS\$5r)\)"5r*"SS\#5r+"SS\+5r,"SS\+5r-"SS\-5r."SS \-5r/"S!S"\-5r0"S#S$\-5r1"S%S&\-5r2\.\/\0\1\24Vs0sHoRfU_M snr4S'r5"S(S)\#5r6"S*S+\$5r7"S,S-\\$5r8"S.S/\85r9"S0S1\85r:"S2S3\$5r;"S4S5\$5r<"S6S7\<5r="S8S9\=5r>"S:S;\>5r?"S<S=\>5r@\"S>5rA"S?S@\<5rB"SASB\B5rC"SCSD\B5rD"SESF\D\C5rE\="SG5rF\="SH5rG\?"SISJ5rH\?"SKSL5rI\?"SMSN5rJ\?"SOSP5rK\@"SQSJ5rL\@"SRSL5rM\@"SSSN5rN\@"STSP5rO\C"SUSLSVSWSX9rP\C"SYSNSJSZSX9rQ\C"S[SPS\S]SX9rR\C"S^S_S`SaSX9rS\C"SbScS`SdSX9rT\C"SeSfSgShSX9rU\E"SSiSP0\QRSjSk9D6rW\E"SSiSc0\RRSjSk9D6rX\<"Sl5rY\B"Sm5rZ\="Sn5r[\D"So5r\\<"Sp5r]"SqSr\$5r^\^"Ss5r_\^"St5r`"SuSv\;5ra"SwSx\a5rb"SySz\$5rc"S{S|\$5rd"S}S~\$5re"SS\$5rf"SS\$5rg\g"S5rh\g"S5ri"SS\$5rj"SS\;5rk"SS\k5rl"SS\$5rm"SS\$\5rn"SS\$5ro"SS\$5rpgs snf)a| Types used to represent a full function/module as an Abstract Syntax Tree. Most types are small, and are merely used as tokens in the AST. A tree diagram has been included below to illustrate the relationships between the AST types. AST Type Tree ------------- :: *Basic* | | CodegenAST | |--->AssignmentBase | |--->Assignment | |--->AugmentedAssignment | |--->AddAugmentedAssignment | |--->SubAugmentedAssignment | |--->MulAugmentedAssignment | |--->DivAugmentedAssignment | |--->ModAugmentedAssignment | |--->CodeBlock | | |--->Token |--->Attribute |--->For |--->String | |--->QuotedString | |--->Comment |--->Type | |--->IntBaseType | | |--->_SizedIntType | | |--->SignedIntType | | |--->UnsignedIntType | |--->FloatBaseType | |--->FloatType | |--->ComplexBaseType | |--->ComplexType |--->Node | |--->Variable | | |---> Pointer | |--->FunctionPrototype | |--->FunctionDefinition |--->Element |--->Declaration |--->While |--->Scope |--->Stream |--->Print |--->FunctionCall |--->BreakToken |--->ContinueToken |--->NoneToken |--->Return Predefined types ---------------- A number of ``Type`` instances are provided in the ``sympy.codegen.ast`` module for convenience. Perhaps the two most common ones for code-generation (of numeric codes) are ``float32`` and ``float64`` (known as single and double precision respectively). There are also precision generic versions of Types (for which the codeprinters selects the underlying data type at time of printing): ``real``, ``integer``, ``complex_``, ``bool_``. The other ``Type`` instances defined are: - ``intc``: Integer type used by C's "int". - ``intp``: Integer type used by C's "unsigned". - ``int8``, ``int16``, ``int32``, ``int64``: n-bit integers. - ``uint8``, ``uint16``, ``uint32``, ``uint64``: n-bit unsigned integers. - ``float80``: known as "extended precision" on modern x86/amd64 hardware. - ``complex64``: Complex number represented by two ``float32`` numbers - ``complex128``: Complex number represented by two ``float64`` numbers Using the nodes --------------- It is possible to construct simple algorithms using the AST nodes. Let's construct a loop applying Newton's method:: >>> from sympy import symbols, cos >>> from sympy.codegen.ast import While, Assignment, aug_assign, Print, QuotedString >>> t, dx, x = symbols('tol delta val') >>> expr = cos(x) - x**3 >>> whl = While(abs(dx) > t, [ ... Assignment(dx, -expr/expr.diff(x)), ... aug_assign(x, '+', dx), ... Print([x]) ... ]) >>> from sympy import pycode >>> py_str = pycode(whl) >>> print(py_str) while (abs(delta) > tol): delta = (val**3 - math.cos(val))/(-3*val**2 - math.sin(val)) val += delta print(val) >>> import math >>> tol, val, delta = 1e-5, 0.5, float('inf') >>> exec(py_str) 1.1121416371 0.909672693737 0.867263818209 0.865477135298 0.865474033111 >>> print('%3.1g' % (math.cos(val) - val**3)) -3e-11 If we want to generate Fortran code for the same while loop we simple call ``fcode``:: >>> from sympy import fcode >>> print(fcode(whl, standard=2003, source_format='free')) do while (abs(delta) > tol) delta = (val**3 - cos(val))/(-3*val**2 - sin(val)) val = val + delta print *, val end do There is a function constructing a loop (or a complete function) like this in :mod:`sympy.codegen.algorithms`. ) annotations)Any) defaultdict)GeGtLeLt)SymbolTupleDummy)Basic)ExprAtom)FloatIntegeroo)_sympifysympify SympifyError)iterabletopological_sortnumbered_symbolsfilter_symbolscUVs/sH%n[U[5(a [U5OUPM' nn[U6$s snf)z Create a SymPy Tuple object from an iterable, converting Python strings to AST strings. Parameters ========== args: iterable Arguments to :class:`sympy.Tuple`. Returns ======= sympy.Tuple ) isinstancestrStringr )argsargs I/var/www/auris/envauris/lib/python3.13/site-packages/sympy/codegen/ast.py _mk_Tupler!s? EI IDS:c3//F3KS 8DD I $< Js,;c\rSrSrSrSrg) CodegenASTN)__name__ __module__ __qualname____firstlineno__ __slots____static_attributes__r%r r#r#sIr,r#c^\rSrSr%SrSrS\S'\r0rS\S'/r S\S 'S /r \ S 5r \ S 5r\ S 5rSrSrSrU4SjrSrSrSS.Sjr\rSrSSjrSrU=r$)TokenaBase class for the AST types. Explanation =========== Defining fields are set in ``_fields``. Attributes (defined in _fields) are only allowed to contain instances of Basic (unless atomic, see ``String``). The arguments to ``__new__()`` correspond to the attributes in the order defined in ``_fields`. The ``defaults`` class attribute is a dictionary mapping attribute names to their default values. Subclasses should not need to override the ``__new__()`` method. They may define a class or static method named ``_construct_`` for each attribute to process the value passed to ``__new__()``. Attributes listed in the class attribute ``not_in_args`` are not passed to :class:`~.Basic`. r%tuple[str, ...]r*dict[str, Any]defaultsz list[str] not_in_argsbodyc2[UR5S:H$Nr)len_fieldsselfs r is_Atom Token.is_Atoms4<< A%%r,c$[USU-S5$)z7Get the constructor function for an attribute by name. z _construct_%scU$Nr%)xs r (Token._get_constructor..sar,)getattr)clsattrs r _get_constructorToken._get_constructorssOd2K@@r,cUS:Xa URRU[5$[U[5(aU$UR U5"U5$)zDConstruct an attribute value from argument passed to ``__new__()``. N)r2getnonerr rF)rDrErs r _constructToken._constructsJ $;<<##D$/ /#u%% ++D1#66r,c[U5S:Xa U(d[USU5(aUS$[U5[UR5:a,[S[U5[UR54-5e/n[ URU5H8upEXB;a[ SU-5eUR URXE55 M: UR[U5SHgnXB;aURU5nO-X@R;aURUnO[ SU-5eUR URXE55 Mi U(a[SSRU5-5e[ URU5VVs/sHupgX`R;dMUPM nnn[R"U/UQ76n [ URU5Hupj[XU 5 M U $s snnf)Nrz,Too many arguments (%d), expected at most %dz$Got multiple values for attribute %rz2No value for %r given and attribute has no defaultzUnknown keyword arguments: %s )r7rr8 ValueErrorzip TypeErrorappendrKpopr2joinr3r#__new__setattr) rDrkwargsattrvalsattrnameargvalrEval basic_argsobjrs r rV Token.__new__s t9>&ZQ-E-E7N t9s3;;' 'KsSWyZ]^a^i^iZjNkkl l!$CKK 6 H! F QRR OOCNN8< = !7 CIJ/H!H-\\)h/ TW_ _`` OOCNN8< =0 [TU]5$r?super__hash__r:ras r rlToken.__hash__w!!r,c4XR;aSSU--$S$)N, rO, ) indented_args)r:k indent_levels r _joiner Token._joiners"-.2D2D-DL((N$Nr,c^^^^^^ TRSm UU UUUU4Sjn[U[5(aTRTT 5R UR Vs/sH ov"U5PM sn5nTTR ;aSST --U-S-ST S- --S-$[UR 5S:XaS RU5$S RU5$U"U5$s snf) Nruc>[U[5(a(TR"U/TQ7STRTT50TD6$TR"U/TQ70TD6$)Njoiner)rr._printrv)rrilrtrXprinterr:s r r{Token._indented.._printsS#u%%~~cWDWa9LWPVWW~~c;D;F;;r,z( rOrq)rNz({0},)z({0})) _contextrr rvrUrrsr7format) r:r}rtvrrXr{rjoinedr|s ``` `` @r _indentedToken._indenteds   n - < < a  \\!R(--aff.Mfsvc{f.MNFD&&&s2v~.6b1fEKK$'K1$4II&QQ'II&QQ!9  /NsC$rr)rzcSSKJn URSS5nURVs/sHn[ X5PM nnUR RSS5n /n [ [URU55Hun upX;aMXR;aXRU :XaM2XR;aU S-OSnU"XS9 UR"XU /UQ70UD6nSSS5 U RU S:XaSOS RU WR555 M S RURRUR!U 55$s snf!,(df  N=f) Nr)printer_contextexcluder%rur)ruz{1}z{0}={1}z{}({}))sympy.printing.printerrrIr8rCr enumeraterQr2rsrrSrlstriprar&rU)r:r}rzrrXrrrtvaluesru arg_reprsirEvalueilvlindenteds r _sympyreprToken._sympyrepr%s2:**Y+,0LL9Lq'$"L9''++NA>  )#dllF*C D A}}}$--2E)E'+/A/A'A>'PPP=   qAve9DDT8??K\] ^!Et~~66 I8NOO%:=s(T{r,cURVs0sHo3U;dM U[X5_M nnUb+UR5VVs0sH up5X2"U5_M snn$U$s snfs snnf)zGet instance's attributes as dict of keyword arguments. Parameters ========== exclude : collection of str Collection of keywords to exclude. apply : callable, optional Function to apply to all values. )r8rCitems)r:rapplyrtrXrs r rX Token.kwargsBsg04||P|!?O%!WT%%|P  ,2LLN;NDAAuQxKN; ;M Q;s AAA#r%N)r&r'r(r)__doc__r*__annotations__r8r2r3rspropertyr; classmethodrFrKrVrcrgrlrvrr _sympystrrrXr+ __classcell__ras@r r.r.s""$I#G!Hn!KHM &&AA 7 7,\E"O"15P.Ir,r.c\rSrSrSrSrg) BreakTokeniTaRepresents 'break' in C/Python ('exit' in Fortran). Use the premade instance ``break_`` or instantiate manually. Examples ======== >>> from sympy import ccode, fcode >>> from sympy.codegen.ast import break_ >>> ccode(break_) 'break' >>> fcode(break_, source_format='free') 'exit' r%Nr&r'r(r)rr+r%r,r rrT r,rc\rSrSrSrSrg) ContinueTokeniga.Represents 'continue' in C/Python ('cycle' in Fortran) Use the premade instance ``continue_`` or instantiate manually. Examples ======== >>> from sympy import ccode, fcode >>> from sympy.codegen.ast import continue_ >>> ccode(continue_) 'continue' >>> fcode(continue_, source_format='free') 'cycle' r%Nrr%r,r rrgrr,rc8^\rSrSrSrSrSrU4SjrSrU=r $) NoneTokeniyaThe AST equivalence of Python's NoneType The corresponding instance of Python's ``None`` is ``none``. Examples ======== >>> from sympy.codegen.ast import none, Variable >>> from sympy import pycode >>> print(pycode(Variable('x').as_Declaration(value=none))) x = None c8USL=(d [U[5$r?)rrr:rbs r rcNoneToken.__eq__s}< 5) <[TU]5$r?rjrms r rlNoneToken.__hash__ror,r%) r&r'r(r)rrcrgrlr+rrs@r rrys =""r,rc\^\rSrSrSrU4Sjr\S5r\S5r\ S5r Sr U=r $)AssignmentBaseizAbstract base class for Assignment and AugmentedAssignment. Attributes: =========== op : str Symbol for assignment operator, e.g. "=", "+=", etc. cr>[U5n[U5nURX5 [TU] XU5$r?)r _check_argsrkrV)rDlhsrhsras r rVAssignmentBase.__new__s2smsm !ws--r,c URS$r6rr9s r rAssignmentBase.lhsyy|r,c URS$)NrNrr9s r rAssignmentBase.rhsrr,cSSKJnJn SSKJn SSKJn [XCU[[U4n[X5(d[S[U5-5e[US5=(a [X5(+n[US5=(a [X%5(+n U(a8U (d [S5eURUR:wa [S5eg U (aU(d [S 5eg g ) zrCheck arguments to __new__ and raise exception if any problems found. Derived classes may wish to override this. r) MatrixElement MatrixSymbol)Indexed) ArrayElementz Cannot assign to lhs of type %s.shapez#Cannot assign a scalar to a matrix.z'Dimensions of lhs and rhs do not align.z#Cannot assign a matrix to a scalar.N)"sympy.matrices.expressions.matexprrrsympy.tensor.indexedrsympy.tensor.array.expressionsrr ElementVariablerrRtypehasattrrPr) rDrrrrrr assignable lhs_is_mat rhs_is_mats r rAssignmentBase._check_argss  )0?l7GX #**>cJK K S'*K:c3K/K S'*K:c3K/K   !FGGcii' !JKK(  BC C!+Zr,r%) r&r'r(r)rrVrrrrrr+rrs@r rrsK.DDr,rc\rSrSrSrSrSrg) Assignmentia Represents variable assignment for code generation. Parameters ========== lhs : Expr SymPy object representing the lhs of the expression. These should be singular objects, such as one would use in writing code. Notable types include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that subclass these types are also supported. rhs : Expr SymPy object representing the rhs of the expression. This can be any type, provided its shape corresponds to that of the lhs. For example, a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as the dimensions will not align. Examples ======== >>> from sympy import symbols, MatrixSymbol, Matrix >>> from sympy.codegen.ast import Assignment >>> x, y, z = symbols('x, y, z') >>> Assignment(x, y) Assignment(x, y) >>> Assignment(x, 0) Assignment(x, 0) >>> A = MatrixSymbol('A', 1, 3) >>> mat = Matrix([x, y, z]).T >>> Assignment(A, mat) Assignment(A, Matrix([[x, y, z]])) >>> Assignment(A[0, 1], x) Assignment(A[0, 1], x) z:=r%N)r&r'r(r)ropr+r%r,r rrs"H Br,rc4\rSrSr%SrS\S'\S5rSrg)AugmentedAssignmentiz Base class for augmented assignments. Attributes: =========== binop : str Symbol for binary operation being applied in the assignment, such as "+", "*", etc. z str | Nonebinopc URS-$)N=)rr9s r rAugmentedAssignment.opszzCr,r%N) r&r'r(r)rrrrr+r%r,r rrs!     r,rc\rSrSrSrSrg)AddAugmentedAssignmenti +r%Nr&r'r(r)rr+r%r,r rr  Er,rc\rSrSrSrSrg)SubAugmentedAssignmenti -r%Nrr%r,r rr rr,rc\rSrSrSrSrg)MulAugmentedAssignmenti*r%Nrr%r,r rrrr,rc\rSrSrSrSrg)DivAugmentedAssignmenti/r%Nrr%r,r rrrr,rc\rSrSrSrSrg)ModAugmentedAssignmenti%r%Nrr%r,r rrrr,rcPU[;a[SU-5e[U"X5$)a Create 'lhs op= rhs'. Explanation =========== Represents augmented variable assignment for code generation. This is a convenience function. You can also use the AugmentedAssignment classes directly, like AddAugmentedAssignment(x, y). Parameters ========== lhs : Expr SymPy object representing the lhs of the expression. These should be singular objects, such as one would use in writing code. Notable types include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that subclass these types are also supported. op : str Operator (+, -, /, \*, %). rhs : Expr SymPy object representing the rhs of the expression. This can be any type, provided its shape corresponds to that of the lhs. For example, a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as the dimensions will not align. Examples ======== >>> from sympy import symbols >>> from sympy.codegen.ast import aug_assign >>> x, y = symbols('x, y') >>> aug_assign(x, '+', y) AddAugmentedAssignment(x, y) zUnrecognized operator %s)augassign_classesrP)rrrs r aug_assignr&s/L ""3b899 R  **r,cj^\rSrSrSrSrSrSr\r\ U4Sj5r \ S5r S Sjr S rU=r$) CodeBlockiQa Represents a block of code. Explanation =========== For now only assignments are supported. This restriction will be lifted in the future. Useful attributes on this object are: ``left_hand_sides``: Tuple of left-hand sides of assignments, in order. ``left_hand_sides``: Tuple of right-hand sides of assignments, in order. ``free_symbols``: Free symbols of the expressions in the right-hand sides which do not appear in the left-hand side of an assignment. Useful methods on this object are: ``topological_sort``: Class method. Return a CodeBlock with assignments sorted so that variables are assigned before they are used. ``cse``: Return a new CodeBlock with common subexpressions eliminated and pulled out as assignments. Examples ======== >>> from sympy import symbols, ccode >>> from sympy.codegen.ast import CodeBlock, Assignment >>> x, y = symbols('x y') >>> c = CodeBlock(Assignment(x, 1), Assignment(y, x + 1)) >>> print(ccode(c)) x = 1; y = x + 1; c/n/nUHJn[U[5(dMURupVURU5 URU5 ML [R "U/UQ76n[ U6Ul[ U6UlU$r?) rrrrSr#rVr left_hand_sidesright_hand_sides)rDrrrrrrr^s r rVCodeBlock.__new__zsA!Z((66&&s+ '',    ,t,#_5$&67 r,c,[UR5$r?)iterrr9s r __iter__CodeBlock.__iter__sDIIr,c4URRSS5nSSU--nUR[URUR 55nSR SUS- -URR-5SU--U-S-SUS- --S-$) NrurrqrOz{}( r r) rrIrUmapr{rrrar&)r:r}rrXr|rzrs r rCodeBlock._sympyreprs    ! !.! 4RS;<sBqDzDNN,C,CCEB "&'),b1f68;< =r,cD>[TU][UR5- $r?)rk free_symbolssetrrms r rCodeBlock.free_symbolssw#c$*>*>&???r,c[SU55(d [S5e[SU55(a [S5e[[ U55n[ [5nUH$nUupVX6R RU5 M& /nUHAnUupVURRH n X9Hn URX45 M M" MC [X'/5n U"U VVs/sHupVUPM snn6$s snnf)a Return a CodeBlock with topologically sorted assignments so that variables are assigned before they are used. Examples ======== The existing order of assignments is preserved as much as possible. This function assumes that variables are assigned to only once. This is a class constructor so that the default constructor for CodeBlock can error when variables are used before they are assigned. >>> from sympy import symbols >>> from sympy.codegen.ast import CodeBlock, Assignment >>> x, y, z = symbols('x y z') >>> assignments = [ ... Assignment(x, y + z), ... Assignment(y, z + 1), ... Assignment(z, 2), ... ] >>> CodeBlock.topological_sort(assignments) CodeBlock( Assignment(z, 2), Assignment(y, z + 1), Assignment(x, y + z) ) c3B# UHn[U[5v M g7fr?rr.0rs r -CodeBlock.topological_sort..sBk:a,,kz4CodeBlock.topological_sort only supports Assignmentsc3B# UHn[U[5v M g7fr?rrrs r rrsG;az!011;r zFCodeBlock.topological_sort does not yet work with AugmentedAssignments) allNotImplementedErroranylistrrrrSrrr) rD assignmentsAvar_mapnoderaEdst_nodessrc_nodeordered_assignmentss r rCodeBlock.topological_sortsDBkBBB%&\] ] G;G G G%&no o( ;' (d#DDA EEN ! !$ ' HDAUU'' ' HHHh12!+( /v6#67#641Q#67887s.D cSSKJn [SUR55(d [ S5e[ SUR55(a [ S5e[ UR5H%upgXpRSU;dM[ SU-5e UR[5nUc [5n[X5nU"[UR5XUUS 9up[URU 5V V s/sHup[X5PM n n n U V V s/sHup[X5PM nn n UR!X-5$s sn n fs sn n f) a6 Return a new code block with common subexpressions eliminated. Explanation =========== See the docstring of :func:`sympy.simplify.cse_main.cse` for more information. Examples ======== >>> from sympy import symbols, sin >>> from sympy.codegen.ast import CodeBlock, Assignment >>> x, y, z = symbols('x y z') >>> c = CodeBlock( ... Assignment(x, 1), ... Assignment(y, sin(x) + 1), ... Assignment(z, sin(x) - 1), ... ) ... >>> c.cse() CodeBlock( Assignment(x, 1), Assignment(x0, sin(x)), Assignment(y, x0 + 1), Assignment(z, x0 - 1) ) r)csec3B# UHn[U[5v M g7fr?rrs r r CodeBlock.cse..s@i:a,,ir z'CodeBlock.cse only supports Assignmentsc3B# UHn[U[5v M g7fr?r rs r rrsE9az!0119r z9CodeBlock.cse does not yet work with AugmentedAssignmentsNzEDuplicate assignments to the same variable are not yet supported (%s))symbols optimizations postprocessorder)sympy.simplify.cse_mainrr rr rrratomsr rrrrrQrr)r:r r!r"r#rrrexisting_symbols replacements reduced_exprsvarexpr new_blocknew_assignmentss r r CodeBlock.csesJB 0@dii@@@%&OP P E499E E E%&ab b 4 45FA**2A..)+:>> from sympy import symbols, Range >>> from sympy.codegen.ast import aug_assign, For >>> x, i, j, k = symbols('x i j k') >>> for_i = For(i, Range(10), [aug_assign(x, '+', i*j*k)]) >>> for_i # doctest: -NORMALIZE_WHITESPACE For(i, iterable=Range(0, 10, 1), body=CodeBlock( AddAugmentedAssignment(x, i*j*k) )) >>> for_ji = For(j, Range(7), [for_i]) >>> for_ji # doctest: -NORMALIZE_WHITESPACE For(j, iterable=Range(0, 7, 1), body=CodeBlock( For(i, iterable=Range(0, 10, 1), body=CodeBlock( AddAugmentedAssignment(x, i*j*k) )) )) >>> for_kji =For(k, Range(5), [for_ji]) >>> for_kji # doctest: -NORMALIZE_WHITESPACE For(k, iterable=Range(0, 5, 1), body=CodeBlock( For(j, iterable=Range(0, 7, 1), body=CodeBlock( For(i, iterable=Range(0, 10, 1), body=CodeBlock( AddAugmentedAssignment(x, i*j*k) )) )) )) )targetrr4c@[U[5(aU$[U6$r?rrrDitrs r _construct_bodyFor._construct_bodyX c9 % %Jc? "r,c[U5(d [S5e[U[5(a [ U5n[ U5$)Nziterable must be an iterable)rrRrrrfrr4s r _construct_iterableFor._construct_iterable_s7}}:; ; c4 *C}r,r%N)r&r'r(r)rr*r8 staticmethodr_construct_targetrr6r:r+r%r,r r0r0*sE)T98I$X.## r,r0c`\rSrSrSrS=rrS/rSr\ S5r Sr S S jr \ S 5rS rSrg )riha*SymPy object representing a string. Atomic object which is not an expression (as opposed to Symbol). Parameters ========== text : str Examples ======== >>> from sympy.codegen.ast import String >>> f = String('foo') >>> f foo >>> str(f) 'foo' >>> f.text 'foo' >>> print(repr(f)) String('foo') textr@TcF[U[5(d [S5eU$)Nz#Argument text is not a string type.)rrrR)rDr@s r _construct_textString._construct_texts $$$AB B r,cUR$r?r?r:r}rrXs r rString._sympystrs yyr,r%Nc0$r?r%)r:rrs r rX String.kwargss r,c^U4Sj$)Nc>T$r?r%r9sr rAString.func..str,r%r9s`r func String.funcs r,cPSSKJn SRU"UR55$)Nr latex_escapez\texttt{{"{}"}})sympy.printing.latexrPrr@)r:r}rPs r _latex String._latexs5!((dii)@AAr,r)r&r'r(r)rr*r8r3r;rrBrrXrrLrRr+r%r,r rrhsU0$#I(KG Br,rc\rSrSrSrSrg) QuotedStringiz9Represents a string which should be printed with quotes. r%Nrr%r,r rUrUsDr,rUc\rSrSrSrSrg)CommentizRepresents a comment. r%Nrr%r,r rWrWs!r,rWc^\rSrSr%SrSrS\S'\rS\"50r S\S'\ "\ 5r S r S rg ) Nodeia?Subclass of Token, carrying the attribute 'attrs' (Tuple) Examples ======== >>> from sympy.codegen.ast import Node, value_const, pointer_const >>> n1 = Node([value_const]) >>> n1.attr_params('value_const') # get the parameters of attribute (by name) () >>> from sympy.codegen.fnodes import dimension >>> n2 = Node([value_const, dimension(5, 3)]) >>> n2.attr_params(value_const) # get the parameters of attribute (by Attribute instance) () >>> n2.attr_params('dimension') # get the parameters of attribute (by name) (5, 3) >>> n2.attr_params(pointer_const) is None True )attrsr0r*rZr1r2cURH3n[UR5[U5:XdM'URs $ g)zPReturns the parameters of the Attribute with name ``looking_for`` in self.attrs N)rZrname parameters)r: looking_forrEs r attr_paramsNode.attr_paramss/JJD499~[!11&r,r%N)r&r'r(r)rr*rr8r r2r<r!_construct_attrsr_r+r%r,r rYrYs9(",I+G '1Hn1#I.'r,rYc\\rSrSr%SrSrS\S'\r\r Sr \ S5r Sr S S jrS rS rg )TypeiaIRepresents a type. Explanation =========== The naming is a super-set of NumPy naming. Type has a classmethod ``from_expr`` which offer type deduction. It also has a method ``cast_check`` which casts the argument to its type, possibly raising an exception if rounding error is not within tolerances, or if the value is not representable by the underlying data type (e.g. unsigned integers). Parameters ========== name : str Name of the type, e.g. ``object``, ``int16``, ``float16`` (where the latter two would use the ``Type`` sub-classes ``IntType`` and ``FloatType`` respectively). If a ``Type`` instance is given, the said instance is returned. Examples ======== >>> from sympy.codegen.ast import Type >>> t = Type.from_expr(42) >>> t integer >>> print(repr(t)) IntBaseType(String('integer')) >>> from sympy.codegen.ast import uint8 >>> uint8.cast_check(-1) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Minimum value for data type bigger than new value. >>> from sympy.codegen.ast import float32 >>> v6 = 0.123456 >>> float32.cast_check(v6) 0.123456 >>> v10 = 12345.67894 >>> float32.cast_check(v10) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Casting gives a significantly different value. >>> boost_mp50 = Type('boost::multiprecision::cpp_dec_float_50') >>> from sympy import cxxcode >>> from sympy.codegen.ast import Declaration, Variable >>> cxxcode(Declaration(Variable('x', type=boost_mp50))) 'boost::multiprecision::cpp_dec_float_50 x' References ========== .. [1] https://numpy.org/doc/stable/user/basics.types.html r\r0r*c,[UR5$r?)rr\rEs r rType._sympystrs499~r,c[U[[45(a[$[U[[ 45(d[ USS5(a[$[ USS5(a[$[U[5(d[ USS5(a[$[U[5(d[ USS5(a[$[S5e)a(Deduces type from an expression or a ``Symbol``. Parameters ========== expr : number or SymPy object The type will be deduced from type or properties. Examples ======== >>> from sympy.codegen.ast import Type, integer, complex_ >>> Type.from_expr(2) == integer True >>> from sympy import Symbol >>> Type.from_expr(Symbol('z', complex=True)) == complex_ True >>> Type.from_expr(sum) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Could not deduce type from expr. Raises ====== ValueError when type deduction fails. is_integerFis_real is_complex is_Relationalz Could not deduce type from expr.) rfloatrrealintrrCintegercomplexcomplex_boolbool_rP)rDr*s r from_exprType.from_exprs< dUEN + +K dS'N + +wt\5/Q/QN 4E * *K dG $ $lE(J(JO dD ! !WT?E%J%JL?@ @r,cgr?r%r:rs r _check Type._check-s r,Nc ^^[U5n[S5n[USS5nTc UcSOSXg*--mUU4SjnURU5n UR U 5 X- n [ U 5U"U5:a [ S5eU $)aCasts a value to the data type of the instance. Parameters ========== value : number rtol : floating point number Relative tolerance. (will be deduced if not given). atol : floating point number Absolute tolerance (in addition to ``rtol``). type_aliases : dict Maps substitutions for Type, e.g. {integer: int64, real: float32} Examples ======== >>> from sympy.codegen.ast import integer, float32, int8 >>> integer.cast_check(3.0) == 3 True >>> float32.cast_check(1e-40) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Minimum value for data type bigger than new value. >>> int8.cast_check(256) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Maximum value for data type smaller than new value. >>> v10 = 12345.67894 >>> float32.cast_check(v10) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Casting gives a significantly different value. >>> from sympy.codegen.ast import float64 >>> float64.cast_check(v10) 12345.67894 >>> from sympy import Float >>> v18 = Float('0.123456789012345646') >>> float64.cast_check(v18) Traceback (most recent call last): ... ValueError: Casting gives a significantly different value. >>> from sympy.codegen.ast import float80 >>> float80.cast_check(v18) 0.123456789012345649 decimal_digNgV瞯TT[U5--$r?)abs)numatolrtols r tolType.cast_check..tolgs$s3x-' 'r,z.Casting gives a significantly different value.)rrrC cast_nocheckrxr~rP) r:rrrprecision_targetsr\tenexp10rnew_valdeltas `` r cast_checkType.cast_check0s^enbkmT2 <!M5s3=/@D (##E* G  u:C MN Nr,cSSKJn U"URR5nU"URR 5nSR X45$)NrrOz%\text{{{}}}\left(\texttt{{{}}}\right))rQrPrar&r\r@r)r:r}rP type_namer\s r rR Type._latexss<5 !8!89 DIINN+7>>yOOr,r%)NrN)r&r'r(r)rr*rr8r_construct_namerrrtrxrrRr+r%r,r rcrcsL5l"+I*GO(A(AT AFPr,rcc"\rSrSrSrSrSrSrg) IntBaseTypeizz1Integer base type, contains no size information. r%c*[[U55$r?)rrn)r:rs r rAIntBaseType.}s 73q6?r,N)r&r'r(r)rr*rr+r%r,r rrzs<I2Lr,rc@\rSrSrSr\R \-r\rSr Sr g) _SizedIntTypeinbitscXR:a[SXR4-5eXR:a[SXR4-5eg)NValue is too small: %d < %dValue is too big: %d > %d)minrPmaxrws r rx_SizedIntType._checksK 88 :eXX=NNO O 88 8E88;LLM M r,r%N) r&r'r(r)r*rcr8r_construct_nbitsrxr+r%r,r rrs!IllY&GNr,rc<\rSrSrSrSr\S5r\S5rSr g) SignedIntTypeiz"Represents a signed integer type. r%c(SURS- -*$NrNrr9s r rSignedIntType.minsDJJqL!!!r,c,SURS- -S- $rrr9s r rSignedIntType.maxs4::a< 1$$r,N r&r'r(r)rr*rrrr+r%r,r rrs0-I ""%%r,rc<\rSrSrSrSr\S5r\S5rSr g)UnsignedIntTypeiz%Represents an unsigned integer type. r%cgr6r%r9s r rUnsignedIntType.minsr,c&SUR-S- $rrr9s r rUnsignedIntType.maxs$**}q  r,Nrr%r,r rrs00I !!r,rrc \rSrSrSrSr\rSrg) FloatBaseTypeiz)Represents a floating point number type. r%N) r&r'r(r)rr*rrr+r%r,r rrs4ILr,rc\rSrSrSrSr\R\-r\=r =r r \ S5r \ S5r\ S5r\ S5r\ S5r\ S 5r\ S 5rS rS rS rg) FloatTypeiahRepresents a floating point type with fixed bit width. Base 2 & one sign bit is assumed. Parameters ========== name : str Name of the type. nbits : integer Number of bits used (storage). nmant : integer Number of bits used to represent the mantissa. nexp : integer Number of bits used to represent the mantissa. Examples ======== >>> from sympy import S >>> from sympy.codegen.ast import FloatType >>> half_precision = FloatType('f16', nbits=16, nmant=10, nexp=5) >>> half_precision.max 65504 >>> half_precision.tiny == S(2)**-14 True >>> half_precision.eps == S(2)**-10 True >>> half_precision.dig == 3 True >>> half_precision.decimal_dig == 5 True >>> half_precision.cast_check(1.0) 1.0 >>> half_precision.cast_check(1e5) # doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Maximum value for data type smaller than new value. )rnmantnexpc.[URS- -$)zUThe largest positive number n, such that 2**(n - 1) is a representable finite value. rN)tworr9s r max_exponentFloatType.max_exponentsTYY]##r,c SUR- $)zQThe lowest negative number n, such that 2**(n - 1) is a valid normalized number. )rr9s r min_exponentFloatType.min_exponents4$$$$r,c^S[URS-*-- [UR--$)zMaximum value representable. rN)rrrr9s r r FloatType.maxs.C4::a<((#t/@/@*@@@r,c.[URS- -$)z'The minimum positive normalized value. rN)rrr9s r tinyFloatType.tinys T&&*++r,c*[UR*-$)z9Difference between 1.0 and the next representable value. )rrr9s r eps FloatType.epssdjj[!!r,cZSSKJnJn U"URU"S5-U"S5- 5$)zNumber of decimal digits that are guaranteed to be preserved in text. When converting text -> float -> text, you are guaranteed that at least ``dig`` number of digits are preserved with respect to rounding or overflow. r)floorlogrr{)sympy.functionsrrr)r:rrs r dig FloatType.digs( /TZZ#a&(R011r,cfSSKJnJn U"URS-U"S5-U"S5- S-5$)aDNumber of digits needed to store & load without loss. Explanation =========== Number of decimal digits needed to guarantee that two consecutive conversions (float -> text -> float) to be idempotent. This is useful when one do not want to loose precision due to rounding errors when storing a floating point value as text. r)ceilingrrNrr{)rrrr)r:rrs r r|FloatType.decimal_digs1 1 Q#a&0R81<==r,cU[:Xa[[5$U[*:Xa[[*5$[[[ U5R UR 55UR 5$)6Casts without checking if out of bounds or subnormal. )rrlrrrevalfr|rws r rFloatType.cast_nochecksU B;9  rc\": S--d.>.>?@$BRBRSSr,cXR*:a[SXR*4-5eXR:a[SXR4-5e[U5UR:a [S5eg)Nrrz>Smallest (absolute) value for data type bigger than new value.)rrPr~rrws r rxFloatType._checksk HH9 :ehhY=OOP P 88 8E88;LLM M u: !]^ ^ "r,r%N)r&r'r(r)rr*rcr8rr_construct_nmant_construct_nexprrrrrrrr|rrxr+r%r,r rrs&P,IllY&G >T_r,rc8^\rSrSrSrU4SjrU4SjrSrU=r$)ComplexBaseTypei"r%cp>SSKJnJn [TU]U"U55[TU]U"U55S--$)rrreimy?)rrrrkrr:rrrras r rComplexBaseType.cast_nocheck&s7* G E + G E +B . / r,cj>SSKJnJn [TU]U"U55 [TU]U"U55 g)Nrr)rrrrkrxrs r rxComplexBaseType._check.s&* r%y! r%y!r,) r&r'r(r)r*rrxr+rrs@r rr"sI ""r,rc\rSrSrSrSrSrg) ComplexTypei4z,Represents a complex floating point number. r%N)r&r'r(r)rr*r+r%r,r rr4s 7Ir,rintcintpint8int16int32 int64@uint8uint16uint32uint64float16r{)rrfloat32float64 4float80P?float128pfloat256r)r\rruntypedrmrorprrcL\rSrSrSrS=rrS\"50r\ r \ "\ 5r SrSrg) AttributeiVaAttribute (possibly parametrized) For use with :class:`sympy.codegen.ast.Node` (which takes instances of ``Attribute`` as ``attrs``). Parameters ========== name : str parameters : Tuple Examples ======== >>> from sympy.codegen.ast import Attribute >>> volatile = Attribute('volatile') >>> volatile volatile >>> print(repr(volatile)) Attribute(String('volatile')) >>> a = Attribute('foo', [1, 2, 3]) >>> a foo(1, 2, 3) >>> a.parameters == (1, 2, 3) True )r\r]r]c^^^[UR5nUR(a-USSRUUU4SjUR55-- nU$)Nz(%s)rrc3P># UHnTR"U/TQ70TD6v M g7fr?)r{)rrrrXr}s r r&Attribute._sympystr..zs5*B1@#+2..+&+&$+&1@s#&)rr\r]rU)r:r}rrXresults ``` r rAttribute._sympystrwsNTYY ?? ftyy*B15*B CC CF r,r%N)r&r'r(r)rr*r8r r2rrr<r!_construct_parametersrr+r%r,r rrVs4410Ieg&HO(3r,r value_const pointer_constc\rSrSrSrSr\\R-r\RR5r\R\ \ S.5 \ "\5r\ "\5r\S\"5S4Sj5rSrS rS rS rS rS rSrg)riaRepresents a variable. Parameters ========== symbol : Symbol type : Type (optional) Type of the variable. attrs : iterable of Attribute instances Will be stored as a Tuple. Examples ======== >>> from sympy import Symbol >>> from sympy.codegen.ast import Variable, float32, integer >>> x = Symbol('x') >>> v = Variable(x, type=float32) >>> v.attrs () >>> v == Variable('x') False >>> v == Variable('x', type=float32) True >>> v Variable(x, type=float32) One may also construct a ``Variable`` instance with the type deduced from assumptions about the symbol using the ``deduced`` classmethod: >>> i = Symbol('i', integer=True) >>> v = Variable.deduced(i) >>> v.type == integer True >>> v == Variable('i') False >>> from sympy.codegen.ast import value_const >>> value_const in v.attrs False >>> w = Variable('w', attrs=[value_const]) >>> w Variable(w, attrs=(value_const,)) >>> value_const in w.attrs True >>> w.as_Declaration(value=42) Declaration(Variable(w, value=42, attrs=(value_const,))) )symbolrr)rrNTc[U[5(aU$[RU5nUbU(aUR U5nU"XX#S9$![a [RU5nNCf=f)aAlt. constructor with type deduction from ``Type.from_expr``. Deduces type primarily from ``symbol``, secondarily from ``value``. Parameters ========== symbol : Symbol value : expr (optional) value of the variable. attrs : iterable of Attribute instances cast_check : bool Whether to apply ``Type.cast_check`` on ``value``. Examples ======== >>> from sympy import Symbol >>> from sympy.codegen.ast import Variable, complex_ >>> n = Symbol('n', integer=True) >>> str(Variable.deduced(n).type) 'integer' >>> x = Symbol('x', real=True) >>> v = Variable.deduced(x) >>> v.type real >>> z = Symbol('z', complex=True) >>> Variable.deduced(z).type == complex_ True )rrrZ)rrrcrtrPr)rDrrrZrtype_s r deducedVariable.deducedspB fh ' 'M *NN6*E  $$U+E6U@@  *NN5)E *sAA21A2c zUR5nURU5 [UR"S0UD65$)aConvenience method for creating a Declaration instance. Explanation =========== If the variable of the Declaration need to wrap a modified variable keyword arguments may be passed (overriding e.g. the ``value`` of the Variable instance). Examples ======== >>> from sympy.codegen.ast import Variable, NoneToken >>> x = Variable('x') >>> decl1 = x.as_Declaration() >>> # value is special NoneToken() which must be tested with == operator >>> decl1.variable.value is None # won't work False >>> decl1.variable.value == None # not PEP-8 compliant True >>> decl1.variable.value == NoneToken() # OK True >>> decl2 = x.as_Declaration(value=42.0) >>> decl2.variable.value == 42.0 True r%)rXupdate DeclarationrL)r:rXkws r as_DeclarationVariable.as_Declarations08[[] &499?r?++r,cj[U5nU"XSS9$![a [SU<SU<35ef=f)NzInvalid comparison z < F)evaluate)rrrR)r:rrs r _relationVariable._relation sC H3-C$e,, HD#FG G Hs 2c.URU[5$r?)rr rs r rAVariable.r!:r,c.URU[5$r?)rrrs r rArrr,c.URU[5$r?)rrrs r rArrr,c.URU[5$r?)rrrs r rArrr,r%)r&r'r(r)rr*rYr8r2copyrrrJr<r_construct_symbol_construct_valuerr rrr__lt____le____ge____gt__r+r%r,r rrs/b,I$,,&G}}!!#H OOWt45$W-#G,#'uw4*A*AX,@-;F :F :F :Fr,rc"\rSrSrSrSrSrSrg)Pointeria Represents a pointer. See ``Variable``. Examples ======== Can create instances of ``Element``: >>> from sympy import Symbol >>> from sympy.codegen.ast import Pointer >>> i = Symbol('i', integer=True) >>> p = Pointer('x') >>> p[i+1] Element(x, indices=(i + 1,)) r%c~[URU5$![a [URU45s$f=fr?)rrrR)r:keys r __getitem__Pointer.__getitem__(s: 04;;, , 04;;/ / 0s !<<N)r&r'r(r)rr*r.r+r%r,r r+r+sI0r,r+cn\rSrSrSrS=rr\\S.r\ "\ 5r \ "S5r \ "S5r \ "\ 5rSrg) ri/aSElement in (a possibly N-dimensional) array. Examples ======== >>> from sympy.codegen.ast import Element >>> elem = Element('x', 'ijk') >>> elem.symbol.name == 'x' True >>> elem.indices (i, j, k) >>> from sympy import ccode >>> ccode(elem) 'x[i][j][k]' >>> ccode(Element('x', 'ijk', strides='lmn', offset='o')) 'x[i*l + j*m + k*n + o]' )rindicesstridesoffset)r2r3c[U6$r?r rs r rAElement.E%+r,c[U6$r?r5r6s r rAr7Fr8r,r%N)r&r'r(r)rr*r8rJr2r<rr$_construct_indices_construct_strides_construct_offsetr+r%r,r rr/sL$EDI40H$W-%&=>%&=>$W-r,rc$\rSrSrSrS=rr\rSr g)riJaRepresents a variable declaration Parameters ========== variable : Variable Examples ======== >>> from sympy.codegen.ast import Declaration, NoneToken, untyped >>> z = Declaration('z') >>> z.variable.type == untyped True >>> # value is special NoneToken() which must be tested with == operator >>> z.variable.value is None # won't work False >>> z.variable.value == None # not PEP-8 compliant True >>> z.variable.value == NoneToken() # OK True )variabler%N) r&r'r(r)rr*r8r_construct_variabler+r%r,r rrJs,('I"r,rcB\rSrSrSrS=rr\"S5r\ S5r Sr g)Whileiea0Represents a 'for-loop' in the code. Expressions are of the form: "while condition: body..." Parameters ========== condition : expression convertible to Boolean body : CodeBlock or iterable When passed an iterable it is used to instantiate a CodeBlock. Examples ======== >>> from sympy import symbols, Gt, Abs >>> from sympy.codegen import aug_assign, Assignment, While >>> x, dx = symbols('x dx') >>> expr = 1 - x**2 >>> whl = While(Gt(Abs(dx), 1e-9), [ ... Assignment(dx, -expr/expr.diff(x)), ... aug_assign(x, '+', dx) ... ]) ) conditionr4c[U5$r?)r)conds r rAWhile.sXd^r,c@[U[5(aU$[U6$r?r3r4s r r6While._construct_bodyr8r,r%N) r&r'r(r)rr*r8r<_construct_conditionrr6r+r%r,r rArAes140/I'(CD##r,rAc0\rSrSrSrS=rr\S5rSr g)ScopeizRepresents a scope in the code. Parameters ========== body : CodeBlock or iterable When passed an iterable it is used to instantiate a CodeBlock. r4c@[U[5(aU$[U6$r?r3r4s r r6Scope._construct_bodyr8r,r%N) r&r'r(r)rr*r8rr6r+r%r,r rJrJs%$#I##r,rJc$\rSrSrSrS=rr\rSr g)StreamiaRepresents a stream. There are two predefined Stream instances ``stdout`` & ``stderr``. Parameters ========== name : str Examples ======== >>> from sympy import pycode, Symbol >>> from sympy.codegen.ast import Print, stderr, QuotedString >>> print(pycode(Print(['x'], file=stderr))) print(x, file=sys.stderr) >>> x = Symbol('x') >>> print(pycode(Print([QuotedString('x')], file=stderr))) # print literally "x" print("x", file=sys.stderr) rdr%N) r&r'r(r)rr*r8rrr+r%r,r rOrOs*$#IOr,rOstdoutstderrcB\rSrSrSrS=rr\\S.r\ "\ 5r \ r \rSrg)PrintiajRepresents print command in the code. Parameters ========== formatstring : str *args : Basic instances (or convertible to such through sympify) Examples ======== >>> from sympy.codegen.ast import Print >>> from sympy import pycode >>> print(pycode(Print('x y'.split(), "coordinate: %12.5g %12.5g\\n"))) print("coordinate: %12.5g %12.5g\n" % (x, y), end="") ) print_args format_stringfile)rUrVr%N)r&r'r(r)rr*r8rJr2r<r!_construct_print_argsrU_construct_format_stringrO_construct_filer+r%r,r rSrSs4$BAI!%t4H(3+Or,rScn\rSrSr%SrSr\\R-rS\S'\ r \ r \ S5r\S5rSrg ) FunctionPrototypeiaRepresents a function prototype Allows the user to generate forward declaration in e.g. C/C++. Parameters ========== return_type : Type name : str parameters: iterable of Variable instances attrs : iterable of Attribute instances Examples ======== >>> from sympy import ccode, symbols >>> from sympy.codegen.ast import real, FunctionPrototype >>> x, y = symbols('x y', real=True) >>> fp = FunctionPrototype(real, 'foo', [x, y]) >>> ccode(fp) 'double foo(double x, double y)' ) return_typer\r]r0r8c*Sn[[X56$)Nc[U[5(a UR$[U[5(aU$[R U5$r?)rrr>rrr6s r _var5FunctionPrototype._construct_parameters.._vars<#{++||#C** '',,r,)r r)rr_s r r 'FunctionPrototype._construct_parameterss -c$o&&r,cl[U[5(d [S5eU"S0URSS9D6$)Nz1func_def is not an instance of FunctionDefinitionrKrr%)rFunctionDefinitionrRrX)rDfunc_defs r from_FunctionDefinition)FunctionPrototype.from_FunctionDefinitions5($677OP P8X__Y_788r,r%N)r&r'r(r)rr*rYr8rrc_construct_return_typerrr<r rrer+r%r,r r[r[sR06I(4<<7G_7!O''99r,r[cz\rSrSrSrSr\RSS\-\R-r\ S5r \ S5r Sr g) rciaRepresents a function definition in the code. Parameters ========== return_type : Type name : str parameters: iterable of Variable instances body : CodeBlock or iterable attrs : iterable of Attribute instances Examples ======== >>> from sympy import ccode, symbols >>> from sympy.codegen.ast import real, FunctionPrototype >>> x, y = symbols('x y', real=True) >>> fp = FunctionPrototype(real, 'foo', [x, y]) >>> ccode(fp) 'double foo(double x, double y)' >>> from sympy.codegen.ast import FunctionDefinition, Return >>> body = [Return(x*y)] >>> fd = FunctionDefinition.from_FunctionPrototype(fp, body) >>> print(ccode(fd)) double foo(double x, double y){ return x*y; } rKNc@[U[5(aU$[U6$r?r3r4s r r6"FunctionDefinition._construct_body)r8r,cr[U[5(d [S5eU"SSU0UR5D6$)Nz2func_proto is not an instance of FunctionPrototyper4r%)rr[rRrX)rD func_protor4s r from_FunctionPrototype)FunctionDefinition.from_FunctionPrototype0s8*&788PQ Q44 1 1 344r,r%) r&r'r(r)rr*r[r8rYrr6rnr+r%r,r rcrcsT:I'',y84<<GG## 55r,rcc0\rSrSrSrS=rr\"\5r Sr g)Returni7aRepresents a return command in the code. Parameters ========== return : Basic Examples ======== >>> from sympy.codegen.ast import Return >>> from sympy.printing.pycode import pycode >>> from sympy import Symbol >>> x = Symbol('x') >>> print(pycode(Return(x))) return x )returnr%N) r&r'r(r)rr*r8r<r_construct_returnr+r%r,r rqrq7s$&%I"8,r,rqc6\rSrSrSrS=rr\r\ "S5r Sr g) FunctionCalliNa!Represents a call to a function in the code. Parameters ========== name : str function_args : Tuple Examples ======== >>> from sympy.codegen.ast import FunctionCall >>> from sympy import pycode >>> fcall = FunctionCall('foo', 'bar baz'.split()) >>> print(pycode(fcall)) foo(bar, baz) )r\ function_argsc[U6$r?r5rs r rAFunctionCall.dsr,r%N) r&r'r(r)rr*r8rrr<_construct_function_argsr+r%r,r ruruNs$$43IO+,EFr,ruc \rSrSrSrS=rrSrg)Raiseigz3Prints as 'raise ...' in Python, 'throw ...' in C++) exceptionr%N)r&r'r(r)rr*r8r+r%r,r r{r{gs>((Ir,r{c$\rSrSrSrS=rr\rSr g) RuntimeError_ilzRepresents 'std::runtime_error' in C++ and 'RuntimeError' in Python. Note that the latter is uncommon, and you might want to use e.g. ValueError. )messager%N) r&r'r(r)rr*r8r_construct_messager+r%r,r r~r~ls'&Ir,r~N) complex64) complex128)qr __future__rtypingr collectionsrsympy.core.relationalrrrr sympy.corer r r sympy.core.basicr sympy.core.exprrrsympy.core.numbersrrrsympy.core.sympifyrrrsympy.utilities.iterablesrrrrr!r#r.rbreak_r continue_rrJrrrrrrrrrrrrr0rrUrWrYrcrrrrrrrrrrrrrrrrrrrrrrrrrrXrrrrmrorqrsrr r rr+rrrArJrOrPrQrSr[rcrqrur{r~)rDs0r rsX~@##22++"&11>>II(jJjX E O ""0{8DZ8Dv%%P . $00000  68N 6sIIsN(+VVB VBr;%;|0BT50BdE6E"f" '5 'FtP5tPn3$3 NK N %M % !m !ajD u_ u_n"m"$/9 66VQgr"gr"gr"# 2 & 2 & 2 & Ir 4 Ir 4 Ir" 5 Ir" 5 Z2S 9 Z2S 9  [2 [HY1Z [  ^S ^GNNK\N4] ^  y/V i  9 % V &&P & /* R;tR;h0h02.e.6#%#6##E##L#E#(U2    E6.9.9b,5*,5^-U-.G5$G2)E)  E ]*s M?