ó
¡¼™\c           @  s3  d  Z  d d l m Z m Z d d l m Z d d l m Z d d l m	 Z	 d d l
 m Z m Z d d l m Z d d l Z d	 „  Z d
 „  Z e Z Z e Z Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z  d „  Z! d „  Z" d d „ Z$ d „  Z% d „  Z& d „  Z' d „  Z( d „  Z) d „  Z* d „  Z+ d  „  Z, d! „  Z- d" „  Z. d# „  Z/ d$ „  Z0 d% „  Z1 d& „  Z2 d' „  Z3 d( „  Z4 d) „  Z5 d* „  Z6 d+ „  Z7 d, „  Z8 d- „  Z9 d. „  Z: d/ „  Z; d0 „  Z< d1 „  Z= d2 „  Z> d3 „  Z? d e@ d4 „ ZA d e@ d5 „ ZB d e@ d6 „ ZC d7 „  ZD d8 „  ZE d9 „  ZF d: „  ZG d; „  ZH d< „  ZI d= „  ZJ d> „  ZK d? „  ZL d@ „  ZM dA „  ZN dB „  ZO dC „  ZP e@ dD „ ZQ e@ dE „ ZR dF „  ZS dG „  ZT dH „  ZU d dI „ ZV dJ „  ZW dK „  ZX dL „  ZY dM „  ZZ dN „  Z[ dO „  Z\ d S(P   sE   Basic tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. iÿÿÿÿ(   t   print_functiont   division(   t   oo(   t   igcd(   t   range(   t   monomial_mint   monomial_div(   t   monomial_keyNc         C  s   |  s | j  S|  d Sd S(   sù   
    Return leading coefficient of ``f``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import poly_LC

    >>> poly_LC([], ZZ)
    0
    >>> poly_LC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
    1

    i    N(   t   zero(   t   ft   K(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   poly_LC   s    c         C  s   |  s | j  S|  d Sd S(   sú   
    Return trailing coefficient of ``f``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import poly_TC

    >>> poly_TC([], ZZ)
    0
    >>> poly_TC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
    3

    iÿÿÿÿN(   R   (   R	   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   poly_TC#   s    c         C  s3   x# | r% t  |  | ƒ }  | d 8} q Wt |  | ƒ S(   sý   
    Return the ground leading coefficient.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_ground_LC

    >>> f = ZZ.map([[[1], [2, 3]]])

    >>> dmp_ground_LC(f, 2, ZZ)
    1

    i   (   t   dmp_LCt   dup_LC(   R	   t   uR
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_ground_LC<   s    	c         C  s3   x# | r% t  |  | ƒ }  | d 8} q Wt |  | ƒ S(   sþ   
    Return the ground trailing coefficient.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_ground_TC

    >>> f = ZZ.map([[[1], [2, 3]]])

    >>> dmp_ground_TC(f, 2, ZZ)
    3

    i   (   t   dmp_TCt   dup_TC(   R	   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_ground_TCS   s    	c         C  s…   g  } x6 | r> | j  t |  ƒ d ƒ |  d | d }  } q	 W|  sU | j  d ƒ n | j  t |  ƒ d ƒ t | ƒ t |  | ƒ f S(   s  
    Return the leading term ``c * x_1**n_1 ... x_k**n_k``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_true_LT

    >>> f = ZZ.map([[4], [2, 0], [3, 0, 0]])

    >>> dmp_true_LT(f, 1, ZZ)
    ((2, 0), 4)

    i   i    (   t   appendt   lent   tupleR   (   R	   R   R
   t   monom(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_true_LTj   s    	c         C  s   |  s t  St |  ƒ d S(   sB  
    Return the leading degree of ``f`` in ``K[x]``.

    Note that the degree of 0 is negative infinity (the SymPy object -oo).

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_degree

    >>> f = ZZ.map([1, 2, 0, 3])

    >>> dup_degree(f)
    3

    i   (   R   R   (   R	   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt
   dup_degreeˆ   s    c         C  s&   t  |  | ƒ r t St |  ƒ d Sd S(   s{  
    Return the leading degree of ``f`` in ``x_0`` in ``K[X]``.

    Note that the degree of 0 is negative infinity (the SymPy object -oo).

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_degree

    >>> dmp_degree([[[]]], 2)
    -oo

    >>> f = ZZ.map([[2], [1, 2, 3]])

    >>> dmp_degree(f, 1)
    1

    i   N(   t
   dmp_zero_pR   R   (   R	   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt
   dmp_degreeŸ   s    c         C  sZ   | | k r t  |  | ƒ S| d | d } } t g  |  D] } t | | | | ƒ ^ q8 ƒ S(   s4   Recursive helper function for :func:`dmp_degree_in`.i   (   R   t   maxt   _rec_degree_in(   t   gt   vt   it   jt   c(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR   º   s    c         C  sW   | s t  |  | ƒ S| d k  s+ | | k rD t d | | f ƒ ‚ n  t |  | d | ƒ S(   s6  
    Return the leading degree of ``f`` in ``x_j`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_degree_in

    >>> f = ZZ.map([[2], [1, 2, 3]])

    >>> dmp_degree_in(f, 0, 1)
    1
    >>> dmp_degree_in(f, 1, 1)
    2

    i    s   0 <= j <= %s expected, got %s(   R   t
   IndexErrorR   (   R	   R!   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_degree_inÄ   s
    c         C  sl   t  | | t |  | ƒ ƒ | | <| d k rh | d | d } } x$ |  D] } t | | | | ƒ qH Wn  d S(   s-   Recursive helper for :func:`dmp_degree_list`.i    i   N(   R   R   t   _rec_degree_list(   R   R   R    t   degsR"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR%   Þ   s
     c         C  s/   t  g | d } t |  | d | ƒ t | ƒ S(   s  
    Return a list of degrees of ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_degree_list

    >>> f = ZZ.map([[1], [1, 2, 3]])

    >>> dmp_degree_list(f, 1)
    (1, 2)

    i   i    (   R   R%   R   (   R	   R   R&   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_degree_listé   s    c         C  sH   |  s |  d r |  Sd } x" |  D] } | r2 Pq" | d 7} q" W|  | S(   sÀ   
    Remove leading zeros from ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dup_strip

    >>> dup_strip([0, 0, 1, 2, 3, 0])
    [1, 2, 3, 0]

    i    i   (    (   R	   R    t   cf(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dup_stripþ   s    c         C  sŠ   | s t  |  ƒ St |  | ƒ r# |  Sd | d } } x+ |  D]# } t | | ƒ sT Pq; | d 7} q; W| t |  ƒ k r~ t | ƒ S|  | Sd S(   sÉ   
    Remove leading zeros from ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_strip

    >>> dmp_strip([[], [0, 1, 2], [1]], 1)
    [[0, 1, 2], [1]]

    i    i   N(   R)   R   R   t   dmp_zero(   R	   R   R    R   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dmp_strip  s    

c         C  s³   t  | ƒ t k	 r^ | d k	 rM | j | ƒ rM t d | |  | j f ƒ ‚ n  t | d g ƒ S| sq t | g ƒ St g  ƒ } x+ | D]# } | t |  | | d | ƒ O} q„ W| Sd S(   s*   Recursive helper for :func:`dmp_validate`.s   %s in %s in not of type %si   N(   t   typet   listt   Nonet   of_typet	   TypeErrort   dtypet   sett   _rec_validate(   R	   R   R    R
   t   levelsR"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR3   :  s    !c         C  sC   | s t  |  ƒ S| d } t g  |  D] } t | | ƒ ^ q$ | ƒ S(   s(   Recursive helper for :func:`_rec_strip`.i   (   R)   R+   t
   _rec_strip(   R   R   t   wR"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR5   L  s    

c         C  sJ   t  |  |  d | ƒ } | j ƒ  } | s: t |  | ƒ | f St d ƒ ‚ d S(   st  
    Return the number of levels in ``f`` and recursively strip it.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_validate

    >>> dmp_validate([[], [0, 1, 2], [1]])
    ([[1, 2], [1]], 1)

    >>> dmp_validate([[1], 1])
    Traceback (most recent call last):
    ...
    ValueError: invalid data structure for a multivariate polynomial

    i    s4   invalid data structure for a multivariate polynomialN(   R3   t   popR5   t
   ValueError(   R	   R
   R4   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_validateV  s    c         C  s   t  t t |  ƒ ƒ ƒ S(   s  
    Compute ``x**n * f(1/x)``, i.e.: reverse ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_reverse

    >>> f = ZZ.map([1, 2, 3, 0])

    >>> dup_reverse(f)
    [3, 2, 1]

    (   R)   R-   t   reversed(   R	   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_reverses  s    c         C  s
   t  |  ƒ S(   s  
    Create a new copy of a polynomial ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_copy

    >>> f = ZZ.map([1, 2, 3, 0])

    >>> dup_copy([1, 2, 3, 0])
    [1, 2, 3, 0]

    (   R-   (   R	   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_copy†  s    c         C  s:   | s t  |  ƒ S| d } g  |  D] } t | | ƒ ^ q! S(   s  
    Create a new copy of a polynomial ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_copy

    >>> f = ZZ.map([[1], [1, 2]])

    >>> dmp_copy(f, 1)
    [[1], [1, 2]]

    i   (   R-   t   dmp_copy(   R	   R   R   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR=   ™  s    

c         C  s
   t  |  ƒ S(   s2  
    Convert `f` into a tuple.

    This is needed for hashing. This is similar to dup_copy().

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_copy

    >>> f = ZZ.map([1, 2, 3, 0])

    >>> dup_copy([1, 2, 3, 0])
    [1, 2, 3, 0]

    (   R   (   R	   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_to_tuple±  s    c           s4   | s t  |  ƒ S| d ‰  t  ‡  f d †  |  Dƒ ƒ S(   sG  
    Convert `f` into a nested tuple of tuples.

    This is needed for hashing.  This is similar to dmp_copy().

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_to_tuple

    >>> f = ZZ.map([[1], [1, 2]])

    >>> dmp_to_tuple(f, 1)
    ((1,), (1, 2))

    i   c         3  s   |  ] } t  | ˆ  ƒ Vq d  S(   N(   t   dmp_to_tuple(   t   .0R"   (   R   (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pys	   <genexpr>Ü  s    (   R   (   R	   R   (    (   R   s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR?   Æ  s    

c         C  s&   t  g  |  D] } | j | ƒ ^ q
 ƒ S(   sò   
    Normalize univariate polynomial in the given domain.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_normal

    >>> dup_normal([0, 1.5, 2, 3], ZZ)
    [1, 2, 3]

    (   R)   t   normal(   R	   R
   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt
   dup_normalß  s    c         C  sI   | s t  |  | ƒ S| d } t g  |  D] } t | | | ƒ ^ q' | ƒ S(   sû   
    Normalize a multivariate polynomial in the given domain.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_normal

    >>> dmp_normal([[], [0, 1.5, 2]], 1, ZZ)
    [[1, 2]]

    i   (   RB   R+   t
   dmp_normal(   R	   R   R
   R   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRC   ð  s    
c         C  sI   | d k	 r | | k r |  St g  |  D] } | j | | ƒ ^ q& ƒ Sd S(   sŽ  
    Convert the ground domain of ``f`` from ``K0`` to ``K1``.

    Examples
    ========

    >>> from sympy.polys.rings import ring
    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_convert

    >>> R, x = ring("x", ZZ)

    >>> dup_convert([R(1), R(2)], R.to_domain(), ZZ)
    [1, 2]
    >>> dup_convert([ZZ(1), ZZ(2)], ZZ, R.to_domain())
    [1, 2]

    N(   R.   R)   t   convert(   R	   t   K0t   K1R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_convert  s    c         C  sk   | s t  |  | | ƒ S| d k	 r2 | | k r2 |  S| d } t g  |  D] } t | | | | ƒ ^ qF | ƒ S(   s¤  
    Convert the ground domain of ``f`` from ``K0`` to ``K1``.

    Examples
    ========

    >>> from sympy.polys.rings import ring
    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_convert

    >>> R, x = ring("x", ZZ)

    >>> dmp_convert([[R(1)], [R(2)]], 1, R.to_domain(), ZZ)
    [[1], [2]]
    >>> dmp_convert([[ZZ(1)], [ZZ(2)]], 1, ZZ, R.to_domain())
    [[1], [2]]

    i   N(   RG   R.   R+   t   dmp_convert(   R	   R   RE   RF   R   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRH     s    
c         C  s&   t  g  |  D] } | j | ƒ ^ q
 ƒ S(   s$  
    Convert the ground domain of ``f`` from SymPy to ``K``.

    Examples
    ========

    >>> from sympy import S
    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_from_sympy

    >>> dup_from_sympy([S(1), S(2)], ZZ) == [ZZ(1), ZZ(2)]
    True

    (   R)   t
   from_sympy(   R	   R
   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_from_sympy<  s    c         C  sI   | s t  |  | ƒ S| d } t g  |  D] } t | | | ƒ ^ q' | ƒ S(   s/  
    Convert the ground domain of ``f`` from SymPy to ``K``.

    Examples
    ========

    >>> from sympy import S
    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_from_sympy

    >>> dmp_from_sympy([[S(1)], [S(2)]], 1, ZZ) == [[ZZ(1)], [ZZ(2)]]
    True

    i   (   RJ   R+   t   dmp_from_sympy(   R	   R   R
   R   R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRK   N  s    
c         C  sN   | d k  r t  d | ƒ ‚ n+ | t |  ƒ k r8 | j S|  t |  ƒ | Sd S(   s  
    Return the ``n``-th coefficient of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_nth

    >>> f = ZZ.map([1, 2, 3])

    >>> dup_nth(f, 0, ZZ)
    3
    >>> dup_nth(f, 4, ZZ)
    0

    i    s    'n' must be non-negative, got %iN(   R#   R   R   R   (   R	   t   nR
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_nthe  s
    c         C  sX   | d k  r t  d | ƒ ‚ n5 | t |  ƒ k r? t | d ƒ S|  t |  | ƒ | Sd S(   s)  
    Return the ``n``-th coefficient of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_nth

    >>> f = ZZ.map([[1], [2], [3]])

    >>> dmp_nth(f, 0, 1, ZZ)
    [3]
    >>> dmp_nth(f, 4, 1, ZZ)
    []

    i    s    'n' must be non-negative, got %ii   N(   R#   R   R*   R   (   R	   RL   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_nth  s
    c         C  s‘   | } x„ | D]| } | d k  r2 t  d | ƒ ‚ q | t |  ƒ k rK | j St |  | ƒ } | t k rp d } n  |  | | | d }  } q W|  S(   s  
    Return the ground ``n``-th coefficient of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_ground_nth

    >>> f = ZZ.map([[1], [2, 3]])

    >>> dmp_ground_nth(f, (0, 1), 1, ZZ)
    2

    i    s    `n` must be non-negative, got %iiÿÿÿÿi   (   R#   R   R   R   R   (   R	   t   NR   R
   R   RL   t   d(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_ground_nth™  s    	c         C  s<   x4 | r6 t  |  ƒ d k r t S|  d }  | d 8} q W|  S(   sã   
    Return ``True`` if ``f`` is zero in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_zero_p

    >>> dmp_zero_p([[[[[]]]]], 4)
    True
    >>> dmp_zero_p([[[[[1]]]]], 4)
    False

    i   i    (   R   t   False(   R	   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR   ¹  s    	
c         C  s*   g  } x t  |  ƒ D] } | g } q W| S(   sš   
    Return a multivariate zero.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_zero

    >>> dmp_zero(4)
    [[[[[]]]]]

    (   R   (   R   t   rR    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR*   Ò  s    c         C  s   t  |  | j | ƒ S(   sã   
    Return ``True`` if ``f`` is one in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_one_p

    >>> dmp_one_p([[[ZZ(1)]]], 2, ZZ)
    True

    (   t   dmp_ground_pt   one(   R	   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dmp_one_pç  s    c         C  s   t  | j |  ƒ S(   sÎ   
    Return a multivariate one over ``K``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_one

    >>> dmp_one(2, ZZ)
    [[[1]]]

    (   t
   dmp_groundRU   (   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_oneø  s    c         C  s„   | d k	 r  | r  t |  | ƒ Sx4 | rV t |  ƒ d k r? t S|  d }  | d 8} q# W| d k rs t |  ƒ d k S|  | g k Sd S(   sê   
    Return True if ``f`` is constant in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_ground_p

    >>> dmp_ground_p([[[3]]], 3, 2)
    True
    >>> dmp_ground_p([[[4]]], None, 2)
    True

    i   i    N(   R.   R   R   RR   (   R	   R"   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRT   	  s    	
c         C  s8   |  s t  | ƒ Sx! t | d ƒ D] } |  g }  q! W|  S(   sÈ   
    Return a multivariate constant.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_ground

    >>> dmp_ground(3, 5)
    [[[[[[3]]]]]]
    >>> dmp_ground(1, -1)
    1

    i   (   R*   R   (   R"   R   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRW   '  s
    
c         C  sK   |  s
 g  S| d k  r$ | j  g |  Sg  t |  ƒ D] } t | ƒ ^ q1 Sd S(   s  
    Return a list of multivariate zeros.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_zeros

    >>> dmp_zeros(3, 2, ZZ)
    [[[[]]], [[[]]], [[[]]]]
    >>> dmp_zeros(3, -1, ZZ)
    [0, 0, 0]

    i    N(   R   R   R*   (   RL   R   R
   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dmp_zeros?  s
    c         C  sK   | s
 g  S| d k  r! |  g | Sg  t  | ƒ D] } t |  | ƒ ^ q. Sd S(   s#  
    Return a list of multivariate constants.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_grounds

    >>> dmp_grounds(ZZ(4), 3, 2)
    [[[[4]]], [[[4]]], [[[4]]]]
    >>> dmp_grounds(ZZ(4), 3, -1)
    [4, 4, 4]

    i    N(   R   RW   (   R"   RL   R   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_groundsX  s
    c         C  s   | j  t |  | | ƒ ƒ S(   s/  
    Return ``True`` if ``LC(f)`` is negative.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_negative_p

    >>> dmp_negative_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
    False
    >>> dmp_negative_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
    True

    (   t   is_negativeR   (   R	   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_negative_pq  s    c         C  s   | j  t |  | | ƒ ƒ S(   s/  
    Return ``True`` if ``LC(f)`` is positive.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_positive_p

    >>> dmp_positive_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
    True
    >>> dmp_positive_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
    False

    (   t   is_positiveR   (   R	   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_positive_p„  s    c         C  sÀ   |  s
 g  St  |  j ƒ  ƒ g  } } t | ƒ t k rq x~ t | d d ƒ D]" } | j |  j | | j ƒ ƒ qH WnE | \ } x9 t | d d ƒ D]% } | j |  j | f | j ƒ ƒ q Wt | ƒ S(   s5  
    Create a ``K[x]`` polynomial from a ``dict``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_from_dict

    >>> dup_from_dict({(0,): ZZ(7), (2,): ZZ(5), (4,): ZZ(1)}, ZZ)
    [1, 0, 5, 0, 7]
    >>> dup_from_dict({}, ZZ)
    []

    iÿÿÿÿ(	   R   t   keysR,   t   intR   R   t   getR   R)   (   R	   R
   RL   t   ht   k(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_from_dict—  s    #	#c         C  sf   |  s
 g  St  |  j ƒ  ƒ g  } } x6 t | d d ƒ D]" } | j |  j | | j ƒ ƒ q6 Wt | ƒ S(   s  
    Create a ``K[x]`` polynomial from a raw ``dict``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_from_raw_dict

    >>> dup_from_raw_dict({0: ZZ(7), 2: ZZ(5), 4: ZZ(1)}, ZZ)
    [1, 0, 5, 0, 7]

    iÿÿÿÿ(   R   R_   R   R   Ra   R   R)   (   R	   R
   RL   Rb   Rc   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_from_raw_dict¸  s     c         C  s!  | s t  |  | ƒ S|  s# t | ƒ Si  } x] |  j ƒ  D]O \ } } | d | d } } | | k rt | | | | <q6 i | | 6| | <q6 Wt | j ƒ  ƒ | d g  } }	 }
 xd t | d d ƒ D]P } | j | ƒ } | d k	 rý |
 j t	 | |	 | ƒ ƒ qÀ |
 j t |	 ƒ ƒ qÀ Wt
 |
 | ƒ S(   sF  
    Create a ``K[X]`` polynomial from a ``dict``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_from_dict

    >>> dmp_from_dict({(0, 0): ZZ(3), (0, 1): ZZ(2), (2, 1): ZZ(1)}, 1, ZZ)
    [[1, 0], [], [2, 3]]
    >>> dmp_from_dict({}, 0, ZZ)
    []

    i    i   iÿÿÿÿN(   Rd   R*   t   itemsR   R_   R   Ra   R.   R   t   dmp_from_dictR+   (   R	   R   R
   t   coeffsR   t   coefft   headt   tailRL   R   Rb   Rc   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRg   Ñ  s"    
$c         C  sz   |  r | r i | j  d 6St |  ƒ d i  } } xA t d | d ƒ D], } |  | | rF |  | | | | f <qF qF W| S(   sí   
    Convert ``K[x]`` polynomial to a ``dict``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dup_to_dict

    >>> dup_to_dict([1, 0, 5, 0, 7])
    {(0,): 7, (2,): 5, (4,): 1}
    >>> dup_to_dict([])
    {}

    i    i   (   i    (   R   R   R   (   R	   R
   R   RL   t   resultRc   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_to_dictý  s    c         C  sw   |  r | r i | j  d 6St |  ƒ d i  } } x> t d | d ƒ D]) } |  | | rF |  | | | | <qF qF W| S(   sÓ   
    Convert a ``K[x]`` polynomial to a raw ``dict``.

    Examples
    ========

    >>> from sympy.polys.densebasic import dup_to_raw_dict

    >>> dup_to_raw_dict([1, 0, 5, 0, 7])
    {0: 7, 2: 5, 4: 1}

    i    i   (   R   R   R   (   R	   R
   R   RL   Rl   Rc   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_to_raw_dict  s    c         C  sâ   | s t  |  | d | ƒSt |  | ƒ rD | rD i | j d | d 6St |  | ƒ | d i  } } } | t k r{ d } n  x` t d | d ƒ D]K } t |  | | | ƒ } x+ | j ƒ  D] \ }	 }
 |
 | | f |	 <q¹ Wq W| S(   s  
    Convert a ``K[X]`` polynomial to a ``dict````.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_to_dict

    >>> dmp_to_dict([[1, 0], [], [2, 3]], 1)
    {(0, 0): 3, (0, 1): 2, (2, 1): 1}
    >>> dmp_to_dict([], 0)
    {}

    R   i    i   iÿÿÿÿ(   i    (   Rm   R   R   R   R   R   t   dmp_to_dictRf   (   R	   R   R
   R   RL   R   Rl   Rc   Rb   t   expRi   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRo   1  s    !	c   	      C  sÕ   | d k  s0 | d k  s0 | | k s0 | | k rC t  d | ƒ ‚ n | | k rS |  St |  | ƒ i  } } xY | j ƒ  D]K \ } } | | | |  | | f | | d | !| | f | | d <qv Wt | | | ƒ S(   s  
    Transform ``K[..x_i..x_j..]`` to ``K[..x_j..x_i..]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_swap

    >>> f = ZZ.map([[[2], [1, 0]], []])

    >>> dmp_swap(f, 0, 1, 2, ZZ)
    [[[2], []], [[1, 0], []]]
    >>> dmp_swap(f, 1, 2, 2, ZZ)
    [[[1], [2, 0]], [[]]]
    >>> dmp_swap(f, 0, 2, 2, ZZ)
    [[[1, 0]], [[2, 0], []]]

    i    s   0 <= i < j <= %s expectedi   (   R#   Ro   Rf   Rg   (	   R	   R    R!   R   R
   t   Ft   HRp   Ri   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_swapT  s    0Cc         C  s   t  |  | ƒ i  } } xg | j ƒ  D]Y \ } } d g t | ƒ } x' t | | ƒ D] \ }	 }
 |	 | |
 <qR W| | t | ƒ <q# Wt | | | ƒ S(   st  
    Return a polynomial in ``K[x_{P(1)},..,x_{P(n)}]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_permute

    >>> f = ZZ.map([[[2], [1, 0]], []])

    >>> dmp_permute(f, [1, 0, 2], 2, ZZ)
    [[[2], []], [[1, 0], []]]
    >>> dmp_permute(f, [1, 2, 0], 2, ZZ)
    [[[1], []], [[2, 0], []]]

    i    (   Ro   Rf   R   t   zipR   Rg   (   R	   t   PR   R
   Rq   Rr   Rp   Ri   t   new_expt   et   p(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_permutew  s    c         C  s@   t  |  t ƒ s t |  | ƒ Sx t | ƒ D] } |  g }  q) W|  S(   sè   
    Return a multivariate value nested ``l``-levels.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_nest

    >>> dmp_nest([[ZZ(1)]], 2, ZZ)
    [[[[1]]]]

    (   t
   isinstanceR-   RW   R   (   R	   t   lR
   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_nest–  s
    c         C  sz   | s
 |  S| sJ |  s  t  | ƒ S| d } g  |  D] } t | | ƒ ^ q1 S| d } g  |  D] } t | | | | ƒ ^ q[ S(   s  
    Return a multivariate polynomial raised ``l``-levels.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_raise

    >>> f = ZZ.map([[], [1, 2]])

    >>> dmp_raise(f, 2, 1, ZZ)
    [[[[]]], [[[1]], [[2]]]]

    i   (   R*   RW   t	   dmp_raise(   R	   R{   R   R
   Rc   R"   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR}   ­  s    

 
c         C  s   t  |  ƒ d k r d |  f Sd } xT t t |  ƒ ƒ D]@ } |  | d sP q5 n  t | | ƒ } | d k r5 d |  f Sq5 W| |  d d | … f S(   s  
    Map ``x**m`` to ``y`` in a polynomial in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_deflate

    >>> f = ZZ.map([1, 0, 0, 1, 0, 0, 1])

    >>> dup_deflate(f, ZZ)
    (3, [1, 1, 1])

    i    i   N(   R   R   R   R   (   R	   R
   R   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_deflateÍ  s    
c         C  s]  t  |  | ƒ r! d | d |  f St |  | ƒ } d g | d } xH | j ƒ  D]: } x1 t | ƒ D]# \ } } t | | | ƒ | | <qa WqN Wx- t | ƒ D] \ } } | s™ d | | <q™ q™ Wt | ƒ } t d „  | Dƒ ƒ rè | |  f Si  }	 xV | j ƒ  D]H \ }
 } g  t |
 | ƒ D] \ } } | | ^ q} | |	 t | ƒ <qû W| t	 |	 | | ƒ f S(   s5  
    Map ``x_i**m_i`` to ``y_i`` in a polynomial in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_deflate

    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])

    >>> dmp_deflate(f, 1, ZZ)
    ((2, 3), [[1, 2], [3, 4]])

    i   i    c         s  s   |  ] } | d  k Vq d S(   i   N(    (   R@   t   b(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pys	   <genexpr>  s    (   i   (
   R   Ro   R_   t	   enumerateR   R   t   allRf   Rt   Rg   (   R	   R   R
   Rq   t   Bt   MR    t   mR   Rr   t   ARi   t   aRO   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_deflateî  s$    
,c         C  sÏ   d } x– |  D]Ž } t  | ƒ d k r/ d |  f Sd } xT t t | ƒ ƒ D]@ } | | d sc qH n  t | | ƒ } | d k rH d |  f SqH Wt | | ƒ } q W| t g  |  D] } | d d | … ^ q¬ ƒ f S(   sP  
    Map ``x**m`` to ``y`` in a set of polynomials in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_multi_deflate

    >>> f = ZZ.map([1, 0, 2, 0, 3])
    >>> g = ZZ.map([4, 0, 0])

    >>> dup_multi_deflate((f, g), ZZ)
    (2, ([1, 2, 3], [4, 0]))

    i    i   N(   R   R   R   R   R   (   t   polysR
   t   GRx   R   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_multi_deflate  s    
c         C  sÅ  | s( t  |  | ƒ \ } } | f | f Sg  d g | d } } x‡ |  D] } t | | ƒ } t | | ƒ s¹ xK | j ƒ  D]: } x1 t | ƒ D]# \ }	 }
 t | |	 |
 ƒ | |	 <q‹ Wqx Wn  | j | ƒ qG Wx- t | ƒ D] \ }	 } | s× d | |	 <q× q× Wt | ƒ } t d „  | Dƒ ƒ r&| |  f Sg  } x† | D]~ } i  } xV | j	 ƒ  D]H \ } } g  t
 | | ƒ D] \ } } | | ^ qh} | | t | ƒ <qLW| j t | | | ƒ ƒ q3W| t | ƒ f S(   s£  
    Map ``x_i**m_i`` to ``y_i`` in a set of polynomials in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_multi_deflate

    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
    >>> g = ZZ.map([[1, 0, 2], [], [3, 0, 4]])

    >>> dmp_multi_deflate((f, g), 1, ZZ)
    ((2, 1), ([[1, 0, 0, 2], [3, 0, 0, 4]], [[1, 0, 2], [3, 0, 4]]))

    i    i   c         s  s   |  ] } | d  k Vq d S(   i   N(    (   R@   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pys	   <genexpr>h  s    (   RŠ   Ro   R   R_   R€   R   R   R   R   Rf   Rt   Rg   (   Rˆ   R   R
   Rƒ   Rr   Rq   R‚   Rx   R	   R    R„   R   Rb   R…   Ri   R†   RO   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_multi_deflateA  s2    "
,c         C  s„   | d k r t  d | ƒ ‚ n  | d k s2 |  r6 |  S|  d g } x: |  d D]. } | j | j g | d ƒ | j | ƒ qN W| S(   s  
    Map ``y`` to ``x**m`` in a polynomial in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_inflate

    >>> f = ZZ.map([1, 1, 1])

    >>> dup_inflate(f, 3, ZZ)
    [1, 0, 0, 1, 0, 0, 1]

    i    s   'm' must be positive, got %si   (   R#   t   extendR   R   (   R	   R„   R
   Rl   Ri   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_inflatey  s    c         C  så   | s t  |  | | | ƒ S| | d k rA t d | | ƒ ‚ n  | d | d } } g  |  D] } t | | | | | ƒ ^ q] }  |  d g } xP |  d D]D }	 x. t d | | ƒ D] }
 | j t | ƒ ƒ q³ W| j |	 ƒ q™ W| S(   s)   Recursive helper for :func:`dmp_inflate`.i    s!   all M[i] must be positive, got %si   (   R   R#   t   _rec_inflateR   R   R*   (   R   Rƒ   R   R    R
   R6   R!   R"   Rl   Ri   t   _(    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRŽ   —  s    +c         C  sN   | s t  |  | d | ƒ St d „  | Dƒ ƒ r4 |  St |  | | d | ƒ Sd S(   s3  
    Map ``y_i`` to ``x_i**k_i`` in a polynomial in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_inflate

    >>> f = ZZ.map([[1, 2], [3, 4]])

    >>> dmp_inflate(f, (2, 3), 1, ZZ)
    [[1, 0, 0, 2], [], [3, 0, 0, 4]]

    i    c         s  s   |  ] } | d  k Vq d S(   i   N(    (   R@   R„   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pys	   <genexpr>À  s    N(   R   R   RŽ   (   R	   Rƒ   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_inflate­  s
    c         C  s%  | s t  |  d | ƒ r& g  |  | f Sg  t |  | ƒ } } xM t d | d ƒ D]8 } x/ | j ƒ  D] } | | rc Pqc qc W| j | ƒ qP W| sŸ g  |  | f Si  }  xT | j ƒ  D]F \ } } t | ƒ } x t | ƒ D] } | | =q× W| |  t	 | ƒ <q² W| t
 | ƒ 8} | t |  | | ƒ | f S(   s[  
    Exclude useless levels from ``f``.

    Return the levels excluded, the new excluded ``f``, and the new ``u``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_exclude

    >>> f = ZZ.map([[[1]], [[1], [2]]])

    >>> dmp_exclude(f, 2, ZZ)
    ([2], [[1], [1, 2]], 1)

    i    i   N(   RT   R.   Ro   R   R_   R   Rf   R-   R:   R   R   Rg   (   R	   R   R
   t   JRq   R!   R   Ri   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_excludeÆ  s$    
c         C  sš   | s
 |  St  |  | ƒ i  } }  xW | j ƒ  D]I \ } } t | ƒ } x | D] } | j | d ƒ qL W| |  t | ƒ <q- W| t | ƒ 7} t |  | | ƒ S(   s  
    Include useless levels in ``f``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_include

    >>> f = ZZ.map([[1], [1, 2]])

    >>> dmp_include(f, [2], 1, ZZ)
    [[[1]], [[1], [2]]]

    i    (   Ro   Rf   R-   t   insertR   R   Rg   (   R	   R‘   R   R
   Rq   R   Ri   R!   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_includeö  s    c         C  sµ   t  |  | ƒ i  }  } | j d } xh |  j ƒ  D]Z \ } } | j ƒ  } x? | j ƒ  D]1 \ } }	 | rx |	 | | | <qU |	 | | | <qU Wq0 W| | d }
 t | |
 | j ƒ |
 f S(   s¯  
    Convert ``f`` from ``K[X][Y]`` to ``K[X,Y]``.

    Examples
    ========

    >>> from sympy.polys.rings import ring
    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_inject

    >>> R, x,y = ring("x,y", ZZ)

    >>> dmp_inject([R(1), x + 2], 0, R.to_domain())
    ([[[1]], [[1], [2]]], 2)
    >>> dmp_inject([R(1), x + 2], 0, R.to_domain(), front=True)
    ([[[1]], [[1, 2]]], 2)

    i   (   Ro   t   ngensRf   t   to_dictRg   t   dom(   R	   R   R
   t   frontRb   R   t   f_monomR   t   g_monomR"   R6   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt
   dmp_inject  s    c         C  sñ   t  |  | ƒ i  }  } | j } | | j d } x} |  j ƒ  D]o \ } } | rg | |  | | }	 }
 n | | | |  }	 }
 |
 | k r› | | |
 |	 <q= i | |	 6| |
 <q= Wx* | j ƒ  D] \ } } | | ƒ | | <q½ Wt | | d | ƒ S(   sü   
    Convert ``f`` from ``K[X,Y]`` to ``K[X][Y]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_eject

    >>> dmp_eject([[[1]], [[1], [2]]], 2, ZZ['x', 'y'])
    [1, x + 2]

    i   (   Ro   R•   Rf   Rg   (   R	   R   R
   R˜   Rb   RL   R   R   R"   Rš   R™   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dmp_eject=  s    	c         C  s`   t  |  | ƒ s |  r  d |  f Sd } x( t |  ƒ D] } | sL | d 7} q3 Pq3 W| |  |  f S(   s  
    Remove GCD of terms from ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_terms_gcd

    >>> f = ZZ.map([1, 0, 1, 0, 0])

    >>> dup_terms_gcd(f, ZZ)
    (2, [1, 0, 1])

    i    i   (   R   R:   (   R	   R
   R    R"   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_terms_gcda  s    
c         C  sÆ   t  |  | | ƒ s! t |  | ƒ r3 d | d |  f St |  | ƒ } t t | j ƒ  ƒ Œ  } t d „  | Dƒ ƒ rz | |  f Si  }  x- | j ƒ  D] \ } } | |  t | | ƒ <q W| t	 |  | | ƒ f S(   s$  
    Remove GCD of terms from ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_terms_gcd

    >>> f = ZZ.map([[1, 0], [1, 0, 0], [], []])

    >>> dmp_terms_gcd(f, 1, ZZ)
    ((2, 1), [[1], [1, 0]])

    i    i   c         s  s   |  ] } | d  k Vq d S(   i    N(    (   R@   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pys	   <genexpr>•  s    (   i    (
   R   R   Ro   R   R-   R_   R   Rf   R   Rg   (   R	   R   R
   Rq   R‰   R   Ri   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_terms_gcd  s    !
c         C  sµ   t  |  | ƒ g  } } | sf x’ t |  ƒ D]6 \ } } | sA q) n  | j | | | f | f ƒ q) WnK | d } x> t |  ƒ D]0 \ } } | j t | | | | | f ƒ ƒ q} W| S(   s,   Recursive helper for :func:`dmp_list_terms`.i   (   R   R€   R   RŒ   t   _rec_list_terms(   R   R   R   RP   t   termsR    R"   R6   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyRŸ      s    %
(c         C  s`   d „  } t  |  | d ƒ } | s9 d | d | j f g S| d k rI | S| | t | ƒ ƒ Sd S(   s¸  
    List all non-zero terms from ``f`` in the given order ``order``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_list_terms

    >>> f = ZZ.map([[1, 1], [2, 3]])

    >>> dmp_list_terms(f, 1, ZZ)
    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
    >>> dmp_list_terms(f, 1, ZZ, order='grevlex')
    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]

    c           s   t  |  d ‡  f d †  d t ƒS(   Nt   keyc           s   ˆ  |  d ƒ S(   Ni    (    (   t   term(   t   O(    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   <lambda>Æ  t    t   reverse(   t   sortedt   True(   R    R£   (    (   R£   s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   sortÅ  s    i    i   N(    (   i    (   RŸ   R   R.   R   (   R	   R   R
   t   orderR©   R    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dmp_list_terms³  s    	c   
      C  s°   t  |  ƒ t  | ƒ } } | | k rg | | k rL | j g | | | } qg | j g | | |  }  n  g  } x6 t |  | ƒ D]% \ } }	 | j | | |	 | Œ ƒ q} Wt | ƒ S(   s8  
    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_apply_pairs

    >>> h = lambda x, y, z: 2*x + y - z

    >>> dup_apply_pairs([1, 2, 3], [3, 2, 1], h, (1,), ZZ)
    [4, 5, 6]

    (   R   R   Rt   R   R)   (
   R	   R   Rb   t   argsR
   RL   R„   Rl   R†   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   dup_apply_pairsÓ  s    c      	   C  sç   | s t  |  | | | | ƒ St |  ƒ t | ƒ | d } } } | | k r’ | | k ru t | | | | ƒ | } q’ t | | | | ƒ |  }  n  g  }	 x? t |  | ƒ D]. \ }
 } |	 j t |
 | | | | | ƒ ƒ q¨ Wt |	 | ƒ S(   sG  
    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dmp_apply_pairs

    >>> h = lambda x, y, z: 2*x + y - z

    >>> dmp_apply_pairs([[1], [2, 3]], [[3], [2, 1]], h, (1,), 1, ZZ)
    [[4], [5, 6]]

    i   (   R­   R   RY   Rt   R   t   dmp_apply_pairsR+   (   R	   R   Rb   R¬   R   R
   RL   R„   R   Rl   R†   R   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR®   ó  s    $&c         C  sw   t  |  ƒ } | | k r% | | } n d } | | k rD | | } n d } |  | | !}  |  sa g  S|  | j g | Sd S(   s=   Take a continuous subsequence of terms of ``f`` in ``K[x]``. i    N(   R   R   (   R	   R„   RL   R
   Rc   Rƒ   RO   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dup_slice  s    c         C  s   t  |  | | d | | ƒ S(   s=   Take a continuous subsequence of terms of ``f`` in ``K[X]``. i    (   t   dmp_slice_in(   R	   R„   RL   R   R
   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt	   dmp_slice+  s    c   
      C  sø   | d k  s | | k r4 t  d | | | f ƒ ‚ n  | sM t |  | | | ƒ St |  | ƒ i  }  } x‚ |  j ƒ  D]t \ } } | | }	 |	 | k  sž |	 | k r» | |  d | | d } n  | | k rÚ | | c | 7<qp | | | <qp Wt | | | ƒ S(   sH   Take a continuous subsequence of terms of ``f`` in ``x_j`` in ``K[X]``. i    s   -%s <= j < %s expected, got %si   (   i    (   R#   R¯   Ro   Rf   Rg   (
   R	   R„   RL   R!   R   R
   R   R   Ri   Rc   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyR°   0  s    
c         C  so   g  t  d |  d ƒ D]! } | j t j | | ƒ ƒ ^ q } x- | d sj | j t j | | ƒ ƒ | d <q> W| S(   s  
    Return a polynomial of degree ``n`` with coefficients in ``[a, b]``.

    Examples
    ========

    >>> from sympy.polys.domains import ZZ
    >>> from sympy.polys.densebasic import dup_random

    >>> dup_random(3, -10, 10, ZZ) #doctest: +SKIP
    [-2, -8, 9, -4]

    i    i   (   R   RD   t   randomt   randint(   RL   R†   R   R
   R   R	   (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt
   dup_randomH  s    ;#(]   t   __doc__t
   __future__R    R   t   sympyR   t
   sympy.coreR   t   sympy.core.compatibilityR   t   sympy.polys.monomialsR   R   t   sympy.polys.orderingsR   R²   R   R   R   R   R   R   R   R   R   R   R   R   R$   R%   R'   R)   R+   R3   R5   R.   R9   R;   R<   R=   R>   R?   RB   RC   RG   RH   RJ   RK   RM   RN   RQ   R   R*   RV   RX   RT   RW   RY   RZ   R\   R^   Rd   Re   Rg   RR   Rm   Rn   Ro   Rs   Ry   R|   R}   R~   R‡   RŠ   R‹   R   RŽ   R   R’   R”   R›   Rœ   R   Rž   RŸ   R«   R­   R®   R¯   R±   R°   R´   (    (    (    s5   lib/python2.7/site-packages/sympy/polys/densebasic.pyt   <module>   s    		

						
					!		
														 											!		,#	#			 	!	,	'	8				0	"%$		!	 	 	#			