U -e#@sddlmZddlmZddlmZddlmZddZdd d ZGd d d Z dd ifddZ ddZ dddZ dddZ dS))Basic)orderedsympify)iterablec cs@|g}|D]0}|Vz||jWq tk r8Yq Xq dS)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 TypeError)exprr ir U/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/sympy/core/traversal.pyiterargssrTc cs~|g}|D]n}|V|rRt|drR|j}t|ddD]}|j|s<|Vq>> 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 Z bound_symbolsF)_firstN) hasattrZcanonical_variablesvalues iterfreeargsZas_dummyhasrr r )r rr r voidr r rr$s  rc@s:eZdZdZd ddZddZddZd d Zd d ZdS)preorder_traversala 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] NcCsd|_||||_dS)NF) _skip_flag_preorder_traversal_pt)selfnodekeysr r r__init__sszpreorder_traversal.__init__ccs|V|jrd|_dSt|tr~|s6t|dr6|j}n|j}|r`|dkrXt||dd}nt|}|D]}|||EdHqdn$t|r|D]}|||EdHqdS)NF_argsetTdefault) r isinstancerrrr rrr)rrrr argitemr r rrws" z&preorder_traversal._preorder_traversalcCs d|_dS)a 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)rrr r rskipszpreorder_traversal.skipcCs t|jSN)nextrr$r r r__next__szpreorder_traversal.__next__cCs|Sr&r r$r r r__iter__szpreorder_traversal.__iter__)N) __name__ __module__ __qualname____doc__rrr%r(r)r r r rrFs , rr cs fddt||S)a8 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 csJs|fS|jr|Sd8fdd|jD}|j|SdS)Nrcsg|]}|qSr r ).0r")_uselevelr r sz%use.._use..)Zis_Atomr __class__)r r0_argsr/r funckwargs)r0rr/szuse.._user)r r5r0r r6r r4ruses r7cgs4t||r0|V|jD]}t|f|EdHqdS)aAIterate 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)etargetr r r rr8s  r8Fcst|dd}|dk r^|rPtfdd|D}||jkrF|j|}|}qr|}n&rz |}Wntk rYnX|S)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 Ncsg|]}t|qSr ) bottom_up)r.aFatomsnonbasicr rr1szbottom_up..)getattrtupler r5r )rvr>r?r@r r r=rr;s      r;Nccs|t|trP|j}|r4|dkr,t||dd}nt|}|D]}t||EdHq8n"t|rr|D]}t||EdHq\|VdS)am 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)] TFrN)r!rr rpostorder_traversalr)rrr r"r#r r rrDs* rD)T)FF)N)basicrZsortingrrZsympy.utilities.iterablesrrrrr7r8r;rDr r r rs     "c