ó
¡¼™\c           @  s‘   d  Z  d d l m Z m Z d d l m Z d d l m Z e d „ Z d „  Z	 e d „ Z
 d	 „  Z d
 „  Z d „  Z e d „ Z d „  Z d S(   sP    Generic Rules for SymPy

This file assumes knowledge of Basic and little else.
iÿÿÿÿ(   t   print_functiont   division(   t   sifti   (   t   newc           s   ‡  ‡ f d †  } | S(   s”   Create a rule to remove identities

    isid - fn :: x -> Bool  --- whether or not this element is an identity

    >>> from sympy.strategies import rm_id
    >>> from sympy import Basic
    >>> remove_zeros = rm_id(lambda x: x==0)
    >>> remove_zeros(Basic(1, 0, 2))
    Basic(1, 2)
    >>> remove_zeros(Basic(0, 0)) # If only identites then we keep one
    Basic(0)

    See Also:
        unpack
    c           sœ   t  t ˆ  |  j ƒ ƒ } t | ƒ d k r. |  St | ƒ t | ƒ k r ˆ |  j g  t |  j | ƒ D] \ } } | sb | ^ qb Œ Sˆ |  j |  j d ƒ Sd S(   s    Remove identities i    N(   t   listt   mapt   argst   sumt   lent	   __class__t   zip(   t   exprt   idst   argt   x(   t   isidR   (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   ident_remove   s    	2(    (   R   R   R   (    (   R   R   s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   rm_id   s    c           s   ‡  ‡ ‡ f d †  } | S(   s   Create a rule to conglomerate identical args

    >>> 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           s˜   t  |  j ˆ ƒ } t ‡ f d †  | j ƒ  Dƒ ƒ } g  | j ƒ  D] \ } } ˆ  | | ƒ ^ qA } t | ƒ t |  j ƒ k r t t |  ƒ | Œ S|  Sd S(   s2    Conglomerate together identical args x + x -> 2x c         3  s0   |  ]& \ } } | t  t ˆ  | ƒ ƒ f Vq d  S(   N(   R   R   (   t   .0t   kR   (   t   count(    s2   lib/python2.7/site-packages/sympy/strategies/rl.pys	   <genexpr>D   s    N(   R   R   t   dictt   itemst   setR   t   type(   R   t   groupst   countst   matt   cntt   newargs(   t   combineR   t   key(    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   conglomerateA   s    ".(    (   R   R   R   R    (    (   R   R   R   s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   glom)   s    
c           s   ‡  ‡ f d †  } | S(   sÇ    Create a rule to sort by a key function

    >>> from sympy.strategies import sort
    >>> from sympy import Basic
    >>> sort_rl = sort(str)
    >>> sort_rl(Basic(3, 1, 2))
    Basic(1, 2, 3)
    c           s   ˆ |  j  t |  j d ˆ  ƒŒ S(   NR   (   R	   t   sortedR   (   R   (   R   R   (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   sort_rlW   s    (    (   R   R   R#   (    (   R   R   s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   sortM   s    
c           s   ‡  ‡ f d †  } | S(   sW   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           s‘   xŠ t  |  j ƒ D]y \ } } t | ˆ ƒ r |  j |  |  j | |  j | d } } } ˆ g  | j D] } ˆ  | | f | Œ  ^ qe Œ  Sq W|  S(   Ni   (   t	   enumerateR   t
   isinstance(   R   t   iR   t   firstt   bt   tail(   t   At   B(    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   distribute_rlk   s
    -5(    (   R+   R,   R-   (    (   R+   R,   s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt
   distribute[   s    c           s   ‡  ‡ f d †  } | S(   s    Replace expressions exactly c           s   |  ˆ  k r ˆ S|  Sd  S(   N(    (   R   (   t   aR)   (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   subs_rlu   s    (    (   R/   R)   R0   (    (   R/   R)   s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   subss   s    c         C  s(   t  |  j ƒ d k r  |  j d S|  Sd S(   s    Rule to unpack singleton args

    >>> from sympy.strategies import unpack
    >>> from sympy import Basic
    >>> unpack(Basic(2))
    2
    i   i    N(   R   R   (   R   (    (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   unpack~   s    c         C  sb   |  j  } g  } x@ |  j D]5 } | j  | k rA | j | j ƒ q | j | ƒ q W| |  j  | Œ S(   s9    Flatten T(a, b, T(c, d), T2(e)) to T(a, b, c, d, T2(e)) (   R	   R   t   extendt   append(   R   R   t   clsR   R   (    (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   flatten‹   s    	c         C  s?   y& t  |  ƒ t t t |  j ƒ ƒ Œ  SWn t k
 r: |  SXd S(   sÅ    Rebuild a SymPy tree

    This function recursively calls constructors in the expression tree.
    This forces canonicalization and removes ugliness introduced by the use of
    Basic.__new__
    N(   R   R   R   t   rebuildR   t	   Exception(   R   (    (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyR7   –   s    &N(   t   __doc__t
   __future__R    R   t   sympy.utilities.iterablesR   t   utilR   R   R!   R$   R.   R1   R2   R6   R7   (    (    (    s2   lib/python2.7/site-packages/sympy/strategies/rl.pyt   <module>   s   	$			