�
��g3 � �^ � d Z ddlmZ ddlmZ efd�Zd� Zefd�Zd� Zd � Z d
� Z
efd�Zd� Zd
S )zP Generic Rules for SymPy
This file assumes knowledge of Basic and little else.
� )�sift� )�newc � � �� � �fd�}|S )a� Create a rule to remove identities.
isid - fn :: x -> Bool --- whether or not this element is an identity.
Examples
========
>>> from sympy.strategies import rm_id
>>> from sympy import Basic, S
>>> remove_zeros = rm_id(lambda x: x==0)
>>> remove_zeros(Basic(S(1), S(0), S(2)))
Basic(1, 2)
>>> remove_zeros(Basic(S(0), S(0))) # If only identites then we keep one
Basic(0)
See Also:
unpack
c �@ �� t t �| j � � � � }t |� � dk r| S t |� � t |� � k r+ �| j gd� t
| j |� � D � � �R � S �| j | j d � � S )z Remove identities r c � � g | ] \ }}|�|��
S � r )�.0�arg�xs �c/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/strategies/rl.py�
<listcomp>z/rm_id.<locals>.ident_remove.<locals>.<listcomp>$ s! � �H�H�H���a�a�H��H�H�H� )�list�map�args�sum�len� __class__�zip)�expr�ids�isidr s ��r
�ident_removezrm_id.<locals>.ident_remove s� �� ��3�t�T�Y�'�'�(�(���s�8�8�q�=�=��K�
��X�X��S���
!�
!��3�t�~� J�H�H�3�t�y�#�+>�+>�H�H�H�J� J� J�
J� �3�t�~�t�y��|�4�4�4r r )r r r s `` r
�rm_idr
s* ��� �& 5� 5� 5� 5� 5� 5� �r c � � ��� ��� fd�}|S )a6 Create a rule to conglomerate identical args.
Examples
========
>>> from sympy.strategies import glom
>>> from sympy import Add
>>> from sympy.abc import x
>>> key = lambda x: x.as_coeff_Mul()[1]
>>> count = lambda x: x.as_coeff_Mul()[0]
>>> combine = lambda cnt, arg: cnt * arg
>>> rl = glom(key, count, combine)
>>> rl(Add(x, -x, 3*x, 2, 3, evaluate=False))
3*x + 5
Wait, how are key, count and combine supposed to work?
>>> key(2*x)
x
>>> count(2*x)
2
>>> combine(2, x)
2*x
c �0 �� t | j �� � }�fd�|� � � D � � }�fd�|� � � D � � }t |� � t | j � � k rt t | � � g|�R � S | S )z2 Conglomerate together identical args x + x -> 2x c �R �� i | ]#\ }}|t t �|� � � � ��$S r )r r )r
�kr �counts �r
�
<dictcomp>z.glom.<locals>.conglomerate.<locals>.<dictcomp>I s1 �� �I�I�I�w�q�$�!�S��U�D�)�)�*�*�I�I�Ir c �. �� g | ]\ }} �||� � ��S r r )r
�mat�cnt�combines �r
r z.glom.<locals>.conglomerate.<locals>.<listcomp>J s) �� �D�D�D���c�7�7�3��$�$�D�D�Dr )r r �items�setr �type)r �groups�counts�newargsr% r �keys ���r
�conglomeratezglom.<locals>.conglomerateF s� �� ��d�i��%�%��I�I�I�I�&�,�,�.�.�I�I�I��D�D�D�D�V�\�\�^�^�D�D�D���w�<�<�3�t�y�>�>�)�)��t�D�z�z�,�G�,�,�,�,��Kr r )r, r r% r- s ``` r
�glomr. + s0 ���� �6� � � � � � � �r c � � �� � �fd�}|S )z� Create a rule to sort by a key function.
Examples
========
>>> from sympy.strategies import sort
>>> from sympy import Basic, S
>>> sort_rl = sort(str)
>>> sort_rl(Basic(S(3), S(1), S(2)))
Basic(1, 2, 3)
c �H �� �| j gt | j ��� � �R � S )N)r, )r �sortedr )r r, r s ��r
�sort_rlzsort.<locals>.sort_rl` s, �� ��s�4�>�?�F�4�9�#�$>�$>�$>�?�?�?�?r r )r, r r2 s `` r
�sortr3 S s- ��� �@� @� @� @� @� @��Nr c � � �� � �fd�}|S )aW Turns an A containing Bs into a B of As
where A, B are container types
>>> from sympy.strategies import distribute
>>> from sympy import Add, Mul, symbols
>>> x, y = symbols('x,y')
>>> dist = distribute(Mul, Add)
>>> expr = Mul(2, x+y, evaluate=False)
>>> expr
2*(x + y)
>>> dist(expr)
2*x + 2*y
c �� ���� t | j � � D ]^\ }}t |�� � rI| j d |� | j | | j |dz d � c�}� ����fd�|j D � � � c S �_| S )Nr c �( �� g | ]} ��|fz �z � ��S r r )r
r �A�first�tails ���r
r z5distribute.<locals>.distribute_rl.<locals>.<listcomp>y s+ �� �I�I�I�3�1�1�u��v�~��4�6�I�I�Ir )� enumerater �
isinstance)r �ir �br8 r9 r7 �Bs @@��r
�
distribute_rlz!distribute.<locals>.distribute_rlu s� ���� ��� �*�*� K� K�F�A�s��#�q�!�!�
K�!%��2�A�2��� �!��d�i��A����>O���q�$��q�I�I�I�I�I�I�!�&�I�I�I�J�J�J�J�
K� �r r )r7 r>