gtddlmZddlmZmZddlmZddlmcm Z ddlm Z efdZ efdZ e fdZ efd ZdS) )partial)chainminimize)identityN)yieldifyc |D]B}t||r0||ttt|||cSC||S)a Apply functions onto recursive containers (tree). Explanation =========== join - a dictionary mapping container types to functions e.g. ``{list: minimize, tuple: chain}`` Keys are containers/iterables. Values are functions [a] -> a. Examples ======== >>> from sympy.strategies.tree import treeapply >>> tree = [(3, 2), (4, 1)] >>> treeapply(tree, {list: max, tuple: min}) 2 >>> add = lambda *args: sum(args) >>> def mul(*args): ... total = 1 ... for arg in args: ... total *= arg ... return total >>> treeapply(tree, {list: mul, tuple: add}) 25 )joinleaf) isinstancemapr treeapply)treer r typs Q/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/strategies/tree.pyr r sw8)) dC  )49c')$T"J"J"J"&(() ) ) ) ) 4::c ptt|}t|t|tt ifi|S)a Execute a strategic tree. Select alternatives greedily Trees ----- Nodes in a tree can be either function - a leaf list - a selection among operations tuple - a sequence of chained operations Textual examples ---------------- Text: Run f, then run g, e.g. ``lambda x: g(f(x))`` Code: ``(f, g)`` Text: Run either f or g, whichever minimizes the objective Code: ``[f, g]`` Textx: Run either f or g, whichever is better, then run h Code: ``([f, g], h)`` Text: Either expand then simplify or try factor then foosimp. Finally print Code: ``([(expand, simplify), (factor, foosimp)], print)`` Objective --------- "Better" is determined by the objective keyword. This function makes choices to minimize the objective. It defaults to the identity. Examples ======== >>> from sympy.strategies.tree import greedy >>> inc = lambda x: x + 1 >>> dec = lambda x: x - 1 >>> double = lambda x: 2*x >>> tree = [inc, (dec, double)] # either inc or dec-then-double >>> fn = greedy(tree) >>> fn(4) # lowest value comes from the inc 5 >>> fn(1) # lowest value comes from dec then double 0 This function selects between options in a tuple. The result is chosen that minimizes the objective function. >>> fn = greedy(tree, objective=lambda x: -x) # maximize >>> fn(4) # highest value comes from the dec then double 6 >>> fn(1) # highest value comes from the inc 2 Greediness ---------- This is a greedy algorithm. In the example: ([a, b], c) # do either a or b, then do c the choice between running ``a`` or ``b`` is made without foresight to c ) objective)rrr listtupler)rrkwargsoptimizes rgreedyr+s8Dx9555H TD(E59 D DV D DDrcjt|ttjttji|S)a Execute a strategic tree. Return all possibilities. Returns a lazy iterator of all possible results Exhaustiveness -------------- This is an exhaustive algorithm. In the example ([a, b], [c, d]) All of the results from (a, c), (b, c), (a, d), (b, d) are returned. This can lead to combinatorial blowup. See sympy.strategies.greedy for details on input )r )r rbranch multiplexrr)rr s r allresultsrqs0( TD&"2E6<H    rc fdS)Nc htttfi|S)N)key)minrr)exprrrrs rzbrute..s>E"<*T"<"r*s,,,,,,,,******(((((((((,,,,,, (    F$CECECECEL#    0#++++++r