\h"SSKJr SSKJr SSKJr SSKJr SSKJr SSK J r Sr SS jr "S S 5r SS 04S jrSrSSjrSSjrg)) annotations)Iterator)Basic)orderedsympify)iterablec#b# U/nUH"nUv URUR5 M$ g7f)aYield the args of a Basic object in a breadth-first traversal. Depth-traversal stops if `arg.args` is either empty or is not an iterable. Examples ======== >>> from sympy import Integral, Function >>> from sympy.abc import x >>> f = Function('f') >>> from sympy.core.traversal import iterargs >>> list(iterargs(Integral(f(x), (f(x), 1)))) [Integral(f(x), (f(x), 1)), f(x), (f(x), 1), x, f(x), 1, x] See Also ======== iterfreeargs, preorder_traversal N)extendargs)exprr is L/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/traversal.pyiterargsr s-& 6D  AFFs-/c#8# U/nUHnUv U(ad[US5(aSURR5n[UR 5SS9HnUR "U6(aMUv M UR UR5 M g7f)aYield the args of a Basic object in a breadth-first traversal. Depth-traversal stops if `arg.args` is either empty or is not an iterable. The bound objects of an expression will be returned as canonical variables. Examples ======== >>> from sympy import Integral, Function >>> from sympy.abc import x >>> f = Function('f') >>> from sympy.core.traversal import iterfreeargs >>> list(iterfreeargs(Integral(f(x), (f(x), 1)))) [Integral(f(x), (f(x), 1)), 1] See Also ======== iterargs, preorder_traversal bound_symbolsF)_firstN)hasattrcanonical_variablesvalues iterfreeargsas_dummyhasr r )rrr rvoids rrr%s{( 6D  ga11((//1D!!**,u=uud||G> AFFs A,B2(Bc>\rSrSrSrS SjrSrSrSrS Sjr S r g) preorder_traversalDa Do a pre-order traversal of a tree. This iterator recursively yields nodes that it has visited in a pre-order fashion. That is, it yields the current node then descends through the tree breadth-first to yield all of a node's children's pre-order traversal. For an expression, the order of the traversal depends on the order of .args, which in many cases can be arbitrary. Parameters ========== node : SymPy expression The expression to traverse. keys : (default None) sort key(s) The key(s) used to sort args of Basic objects. When None, args of Basic objects are processed in arbitrary order. If key is defined, it will be passed along to ordered() as the only key(s) to use to sort the arguments; if ``key`` is simply True then the default keys of ordered will be used. Yields ====== subtree : SymPy expression All of the subtrees in the tree. Examples ======== >>> from sympy import preorder_traversal, symbols >>> x, y, z = symbols('x y z') The nodes are returned in the order that they are encountered unless key is given; simply passing key=True will guarantee that the traversal is unique. >>> list(preorder_traversal((x + y)*z, keys=None)) # doctest: +SKIP [z*(x + y), z, x + y, y, x] >>> list(preorder_traversal((x + y)*z, keys=True)) [z*(x + y), z, x + y, x, y] Nc>SUlURX5Ulg)NF) _skip_flag_preorder_traversal_pt)selfnodekeyss r__init__preorder_traversal.__init__qs++D7c## Uv UR(aSUlg[U[5(awU(d[US5(a URnO UR nU(aUS:wa [ X2SS9nO [ U5nUHnURXB5ShvN M g[U5(a#UHnURXR5ShvN M ggN=N 7f)NF_argsetTdefault) r isinstancerrr*r rr!r )r#r$r%r argitems rr!&preorder_traversal._preorder_traversalus ??#DO  dE " "GD)44||yy4<"4u=D"4=D33C>>> d^^33D????@s$B C$"C #2C$C" C$"C$cSUlg)a7 Skip yielding current node's (last yielded node's) subtrees. Examples ======== >>> from sympy import preorder_traversal, symbols >>> x, y, z = symbols('x y z') >>> pt = preorder_traversal((x + y*z)*z) >>> for i in pt: ... print(i) ... if i == x + y*z: ... pt.skip() z*(x + y*z) z x + y*z TN)r r#s rskippreorder_traversal.skips $r(c,[UR5$N)nextr"r2s r__next__preorder_traversal.__next__sDHH~r(cU$r6r2s r__iter__preorder_traversal.__iter__s r()r"r r6)returnzIterator[Basic]) __name__ __module__ __qualname____firstlineno____doc__r&r!r3r8r<__static_attributes__r;r(rrrDs"+X8@.(r(rr;c@^^^^UUUU4SjmT"[U5U5$)a  Use ``func`` to transform ``expr`` at the given level. Examples ======== >>> from sympy import use, expand >>> from sympy.abc import x, y >>> f = (x + y)**2*x + 1 >>> use(f, expand, level=2) x*(x**2 + 2*x*y + y**2) + 1 >>> expand(f) x**3 + 2*x**2*y + x*y**2 + 1 c>U(d T"U/TQ70TD6$UR(aU$US-nURVs/sH nT"X!5PM nnUR"U6$s snf)Nr)is_Atomr __class__)rlevelr._args_user funckwargss rrKuse.._usesb.t.v. .||  59YY?Ycc)Y?~~u--@sAr)rrLrIr rMrKs ` ``@ruserOs $ . .  u %%r(c'# [X5(a,Uv URHn[U/UQ76ShvN M ggN 7f)aIterate through the args that are the given types (target) and return a list of the args that were traversed; arguments that are not of the specified types are not traversed. Examples ======== >>> from sympy.core.traversal import walk >>> from sympy import Min, Max >>> from sympy.abc import x, y, z >>> list(walk(Min(x, Max(y, Min(1, z))), Min)) [Min(x, Max(y, Min(1, z)))] >>> list(walk(Min(x, Max(y, Min(1, z))), Min, Max)) [Min(x, Max(y, Min(1, z))), Max(y, Min(1, z)), Min(1, z)] See Also ======== bottom_up N)r-r walk)etargetrs rrQrQsB*!AA'' ' ' (s3AA Ac B[USS5nUbfU(aN[UVs/sHn[XQX#5PM sn5nX@R:waUR"U6nU"U5nU$U(aU"U5nU$U(a U"U5nU$U$s snf![ a U$f=f)zApply ``F`` to all expressions in an expression tree from the bottom up. If ``atoms`` is True, apply ``F`` even if there are no args; if ``nonbasic`` is True, try to apply ``F`` to non-Basic objects. r N)getattrtuple bottom_upr rL TypeError)rvFatomsnonbasicr as rrWrWs 2vt $D  DIDq)A%:DIJDwwWWd^2B I2B I  rU I2IJ  I sB ?B BBNc#6# [U[5(aLURnU(aUS:wa [X!SS9nO [U5nUHn[ X15ShvN M O,[ U5(aUHn[ XA5ShvN M Uv gN:N7f)a Do a postorder traversal of a tree. This generator recursively yields nodes that it has visited in a postorder fashion. That is, it descends through the tree depth-first to yield all of a node's children's postorder traversal before yielding the node itself. Parameters ========== node : SymPy expression The expression to traverse. keys : (default None) sort key(s) The key(s) used to sort args of Basic objects. When None, args of Basic objects are processed in arbitrary order. If key is defined, it will be passed along to ordered() as the only key(s) to use to sort the arguments; if ``key`` is simply True then the default keys of ``ordered`` will be used (node count and default_sort_key). Yields ====== subtree : SymPy expression All of the subtrees in the tree. Examples ======== >>> from sympy import postorder_traversal >>> from sympy.abc import w, x, y, z The nodes are returned in the order that they are encountered unless key is given; simply passing key=True will guarantee that the traversal is unique. >>> list(postorder_traversal(w + (x + y)*z)) # doctest: +SKIP [z, y, x, x + y, z*(x + y), w, w + z*(x + y)] >>> list(postorder_traversal(w + (x + y)*z, keys=True)) [w, z, x, y, x + y, z*(x + y), w + z*(x + y)] TFr+N)r-rr rpostorder_traversalr )r$r%r r.r/s rr_r_sT$yy t|t59t}C*35 5 5 $D*46 6 6 J 6 7s$ABB,BBBB)T)FFr6) __future__rtypingrbasicrsortingrr sympy.utilities.iterablesr rrrrOrQrWr_r;r(rresL".2>``F"R&@(606r(