�
��g� � �t � d dl mZ d dlmZmZ d dlmZ d dlmc m Z d dlm
Z
efd�Z efd�Z e
fd�Z
efd �ZdS )
� )�partial)�chain�minimize)�identityN)�yieldifyc
� � |D ]B}t | |� � r0 || t t t ||�� � | � � � c S �C || � � 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
)�join�leaf)�
isinstance�mapr � treeapply)�treer r
�typs �e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/strategies/tree.pyr
r
sw � �8 � )� )�� �d�C� � � )� �4��9�c�'�)�$�T�"J�"J�"J�"&� (� (� )�
)�
)�
)� )� �4��:�:�� c �p � t t |�� � }t | t |t t
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)r r r
�list�tupler )r r �kwargs�optimizes r �greedyr + s8 � �D �x�9�5�5�5�H� �T�D�(�E�5�9� D� D�V� D� D�Dr c �j � t | t t j t t j i|�� � 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
r �branch� multiplexr r )r r
s r �
allresultsr q s0 � �( �T�D�&�"2�E�6�<�H� � � � � r c � � ��� ��� fd�S )Nc
�h �� t t t �fi ���| � � � � ��� � S )N)�key)�minr r )�exprr r r s ���r �<lambda>zbrute.<locals>.<lambda>� s> �� ��E�"<�*�T�"<�"<�V�"<�"<�T�"B�"B� C� C� )�+� +� +� r � )r r r s ```r �bruter$ � s( ���� � +� +� +� +� +� +� +r )� functoolsr �sympy.strategiesr r �sympy.strategies.corer �sympy.strategies.branch�
strategiesr r r
r r r$ r# r r �<module>r* s� �� � � � � � � ,� ,� ,� ,� ,� ,� ,� ,� *� *� *� *� *� *� (� (� (� (� (� (� (� (� (� ,� ,� ,� ,� ,� ,� (� � � � �F $� CE� CE� CE� CE�L #� � � � �0 #� +� +� +� +� +� +r