U
    ZÊ¹jrŒ  ã                   @   s–  d Z ddlmZ ddlmZmZ ddlmZ ddlZe	dƒZ
dd„ Zd	d
„ Ze ZZe ZZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Zd!d"„ Zd#d$„ Zd–d%d&„Zd'd(„ Zd)d*„ Z d+d,„ Z!d-d.„ Z"d/d0„ Z#d1d2„ Z$d3d4„ Z%d5d6„ Z&d7d8„ Z'd9d:„ Z(d;d<„ Z)d=d>„ Z*d?d@„ Z+dAdB„ Z,dCdD„ Z-dEdF„ Z.dGdH„ Z/dIdJ„ Z0dKdL„ Z1dMdN„ Z2dOdP„ Z3dQdR„ Z4dSdT„ Z5dUdV„ Z6dWdX„ Z7dYdZ„ Z8d[d\„ Z9d—d^d_„Z:d˜d`da„Z;d™dbdc„Z<ddde„ Z=dfdg„ Z>dhdi„ Z?djdk„ Z@dldm„ ZAdndo„ ZBdpdq„ ZCdrds„ ZDdtdu„ ZEdvdw„ ZFdxdy„ ZGdzd{„ ZHd|d}„ ZIdšd~d„ZJd›d€d�„ZKd‚dƒ„ ZLd„d…„ ZMd†d‡„ ZNdœdˆd‰„ZOdŠd‹„ ZPdŒd�„ ZQdŽd�„ ZRd�d‘„ ZSd’d“„ ZTd”d•„ ZUdS )�zEBasic tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. é    )Úigcd)Úmonomial_minÚmonomial_div)Úmonomial_keyNz-infc                 C   s   | s
|j S | d S dS )zù
    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

    r   N©Úzero©ÚfÚK© r   úU/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/densebasic.pyÚpoly_LC   s    r   c                 C   s   | s
|j S | d S dS )zú
    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

    éÿÿÿÿNr   r   r   r   r   Úpoly_TC$   s    r   c                 C   s"   |rt | |ƒ} |d8 }q t| |ƒS )zý
    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

    é   )Údmp_LCÚdup_LC©r	   Úur
   r   r   r   Údmp_ground_LC=   s    

r   c                 C   s"   |rt | |ƒ} |d8 }q t| |ƒS )zþ
    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

    r   )Údmp_TCÚdup_TCr   r   r   r   Údmp_ground_TCT   s    

r   c                 C   sb   g }|r.|  t| ƒd ¡ | d |d  } }q| s>|  d¡ n|  t| ƒd ¡ t|ƒt| |ƒfS )a  
    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)

    r   r   )ÚappendÚlenÚtupler   )r	   r   r
   Úmonomr   r   r   Údmp_true_LTk   s    r   c                 C   s   | st S t| ƒd S )a?  
    Return the leading degree of ``f`` in ``K[x]``.

    Note that the degree of 0 is negative infinity (``float('-inf')``).

    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

    r   )Úninfr   ©r	   r   r   r   Ú
dup_degree‰   s    r    c                 C   s   t | |ƒrtS t| ƒd S dS )ay  
    Return the leading degree of ``f`` in ``x_0`` in ``K[X]``.

    Note that the degree of 0 is negative infinity (``float('-inf')``).

    Examples
    ========

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

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

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

    >>> dmp_degree(f, 1)
    1

    r   N)Ú
dmp_zero_pr   r   ©r	   r   r   r   r   Ú
dmp_degree    s    
r#   c                    s>   ˆ ˆkrt | ˆƒS ˆd ˆ d  ‰‰ t‡ ‡‡fdd„| D ƒƒS )z4Recursive helper function for :func:`dmp_degree_in`.r   c                 3   s   | ]}t |ˆˆ ˆƒV  qd S ©N)Ú_rec_degree_in©Ú.0Úc©ÚiÚjÚvr   r   Ú	<genexpr>Â   s     z!_rec_degree_in.<locals>.<genexpr>)r#   Úmax)Úgr,   r*   r+   r   r)   r   r%   »   s    
r%   c                 C   s<   |st | |ƒS |dk s||kr.td||f ƒ‚t| |d|ƒS )a6  
    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

    r   z0 <= j <= %s expected, got %s)r#   Ú
IndexErrorr%   )r	   r+   r   r   r   r   Údmp_degree_inÅ   s
    
r1   c                 C   sN   t || t| |ƒƒ||< |dkrJ|d |d  }}| D ]}t||||ƒ q6dS )z-Recursive helper for :func:`dmp_degree_list`.r   r   N)r.   r#   Ú_rec_degree_list)r/   r,   r*   Údegsr(   r   r   r   r2   ß   s
    r2   c                 C   s$   t g|d  }t| |d|ƒ t|ƒS )a  
    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)

    r   r   )r   r2   r   )r	   r   r3   r   r   r   Údmp_degree_listê   s    r4   c                 C   s<   | r| d r| S d}| D ]}|r& q0q|d7 }q| |d… S )zÀ
    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]

    r   r   Nr   )r	   r*   Úcfr   r   r   Ú	dup_stripÿ   s    
r6   c                 C   sn   |st | ƒS t| |ƒr| S d|d  }}| D ]}t||ƒs@ qJq,|d7 }q,|t| ƒkr^t|ƒS | |d… S dS )zÉ
    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]]

    r   r   N)r6   r!   r   Údmp_zero)r	   r   r*   r,   r(   r   r   r   Ú	dmp_strip  s    


r8   c                 C   sr   t |tƒs:|dk	r0| |¡s0td|| |jf ƒ‚|d hS |sD|hS tƒ }|D ]}|t| ||d |ƒO }qN|S dS )z*Recursive helper for :func:`dmp_validate`.Nz%s in %s in not of type %sr   )Ú
isinstanceÚlistZof_typeÚ	TypeErrorZdtypeÚsetÚ_rec_validate)r	   r/   r*   r
   Úlevelsr(   r   r   r   r=   ;  s    

r=   c                    s,   |st | ƒS |d ‰ t‡ fdd„| D ƒ|ƒS )z(Recursive helper for :func:`_rec_strip`.r   c                    s   g | ]}t |ˆ ƒ‘qS r   )Ú
_rec_stripr&   ©Úwr   r   Ú
<listcomp>T  s     z_rec_strip.<locals>.<listcomp>)r6   r8   )r/   r,   r   r@   r   r?   M  s    r?   c                 C   s4   t | | d|ƒ}| ¡ }|s(t| |ƒ|fS tdƒ‚dS )at  
    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

    r   z4invalid data structure for a multivariate polynomialN)r=   Úpopr?   Ú
ValueError)r	   r
   r>   r   r   r   r   Údmp_validateW  s    ÿrE   c                 C   s   t tt| ƒƒƒS )a  
    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]

    )r6   r:   Úreversedr   r   r   r   Údup_reverset  s    rG   c                 C   s   t | ƒS )a  
    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   r   r   r   Údup_copy‡  s    rI   c                    s&   |st | ƒS |d ‰ ‡ fdd„| D ƒS )a  
    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]]

    r   c                    s   g | ]}t |ˆ ƒ‘qS r   )Údmp_copyr&   ©r,   r   r   rB   ¯  s     zdmp_copy.<locals>.<listcomp>rH   r"   r   rK   r   rJ   š  s    rJ   c                 C   s   t | ƒS )a2  
    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   r   r   r   Údup_to_tuple²  s    rM   c                    s*   |st | ƒS |d ‰ t ‡ fdd„| D ƒƒS )aG  
    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))

    r   c                 3   s   | ]}t |ˆ ƒV  qd S r$   )Údmp_to_tupler&   rK   r   r   r-   Ý  s     zdmp_to_tuple.<locals>.<genexpr>rL   r"   r   rK   r   rN   Ç  s    rN   c                    s   t ‡ fdd„| D ƒƒS )zð
    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, 2, 3], ZZ)
    [1, 2, 3]

    c                    s   g | ]}ˆ   |¡‘qS r   )Únormalr&   ©r
   r   r   rB   î  s     zdup_normal.<locals>.<listcomp>©r6   r   r   rP   r   Ú
dup_normalà  s    rR   c                    s0   |st | ˆ ƒS |d ‰t‡ ‡fdd„| D ƒ|ƒS )zù
    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, 2]], 1, ZZ)
    [[1, 2]]

    r   c                    s   g | ]}t |ˆˆ ƒ‘qS r   )Ú
dmp_normalr&   ©r
   r,   r   r   rB     s     zdmp_normal.<locals>.<listcomp>)rR   r8   r   r   rT   r   rS   ñ  s    
rS   c                    s0   ˆ dk	rˆ ˆkr| S t ‡ ‡fdd„| D ƒƒS dS )aŽ  
    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]

    Nc                    s   g | ]}ˆ  |ˆ ¡‘qS r   )Úconvertr&   ©ÚK0ÚK1r   r   rB     s     zdup_convert.<locals>.<listcomp>rQ   )r	   rW   rX   r   rV   r   Údup_convert  s    rY   c                    sH   |st | ˆ ˆƒS ˆ dk	r$ˆ ˆkr$| S |d ‰t‡ ‡‡fdd„| D ƒ|ƒS )a¤  
    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]]

    Nr   c                    s   g | ]}t |ˆˆ ˆƒ‘qS r   )Údmp_convertr&   ©rW   rX   r,   r   r   rB   :  s     zdmp_convert.<locals>.<listcomp>)rY   r8   )r	   r   rW   rX   r   r[   r   rZ      s    rZ   c                    s   t ‡ fdd„| D ƒƒS )a$  
    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

    c                    s   g | ]}ˆ   |¡‘qS r   )Z
from_sympyr&   rP   r   r   rB   L  s     z"dup_from_sympy.<locals>.<listcomp>rQ   r   r   rP   r   Údup_from_sympy=  s    r\   c                    s0   |st | ˆ ƒS |d ‰t‡ ‡fdd„| D ƒ|ƒS )a/  
    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

    r   c                    s   g | ]}t |ˆˆ ƒ‘qS r   )Údmp_from_sympyr&   rT   r   r   rB   c  s     z"dmp_from_sympy.<locals>.<listcomp>)r\   r8   r   r   rT   r   r]   O  s    
r]   c                 C   s<   |dk rt d| ƒ‚n"|t| ƒkr(|jS | t| ƒ|  S dS )a  
    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

    r   ú 'n' must be non-negative, got %iN)r0   r   r   r    )r	   Únr
   r   r   r   Údup_nthf  s
    r`   c                 C   sD   |dk rt d| ƒ‚n*|t| ƒkr.t|d ƒS | t| |ƒ|  S dS )a)  
    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)
    []

    r   r^   r   N)r0   r   r7   r#   )r	   r_   r   r
   r   r   r   Údmp_nth€  s
    ra   c                 C   sj   |}|D ]\}|dk r"t d| ƒ‚q|t| ƒkr8|j  S t| |ƒ}|tkrNd}| ||  |d  } }q| S )a  
    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

    r   z `n` must be non-negative, got %ir   r   )r0   r   r   r#   r   )r	   ÚNr   r
   r,   r_   Údr   r   r   Údmp_ground_nthš  s    

rd   c                 C   s,   |r&t | ƒdkrdS | d } |d8 }q |  S )zã
    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

    r   Fr   )r   r"   r   r   r   r!   º  s    
r!   c                 C   s   g }t | ƒD ]
}|g}q|S )zš
    Return a multivariate zero.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_zero

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

    ©Úrange)r   Úrr*   r   r   r   r7   Ó  s    r7   c                 C   s   t | |j|ƒS )zã
    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

    )Údmp_ground_pÚoner   r   r   r   Ú	dmp_one_pè  s    rj   c                 C   s   t |j| ƒS )zÎ
    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]]]

    )Ú
dmp_groundri   )r   r
   r   r   r   Údmp_oneù  s    rl   c                 C   s^   |dk	r|st | |ƒS |r<t| ƒdkr*dS | d } |d8 }q|dkrPt| ƒdkS | |gkS dS )zê
    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

    Nr   Fr   )r!   r   )r	   r(   r   r   r   r   rh   
  s    

rh   c                 C   s(   | st |ƒS t|d ƒD ]
}| g} q| S )zÈ
    Return a multivariate constant.

    Examples
    ========

    >>> from sympy.polys.densebasic import dmp_ground

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

    r   )r7   rf   )r(   r   r*   r   r   r   rk   (  s
    rk   c                    s6   | sg S ˆ dk r|j g|  S ‡ fdd„t| ƒD ƒS dS )a  
    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]

    r   c                    s   g | ]}t ˆ ƒ‘qS r   ©r7   ©r'   r*   ©r   r   r   rB   V  s     zdmp_zeros.<locals>.<listcomp>N)r   rf   )r_   r   r
   r   ro   r   Ú	dmp_zeros@  s
    rp   c                    s6   |sg S ˆdk rˆ g| S ‡ ‡fdd„t |ƒD ƒS dS )a#  
    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]

    r   c                    s   g | ]}t ˆ ˆƒ‘qS r   ©rk   rn   ©r(   r   r   r   rB   o  s     zdmp_grounds.<locals>.<listcomp>Nre   )r(   r_   r   r   rr   r   Údmp_groundsY  s
    
rs   c                 C   s   |  t| ||ƒ¡S )a/  
    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

    )Zis_negativer   r   r   r   r   Údmp_negative_pr  s    rt   c                 C   s   |  t| ||ƒ¡S )a/  
    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

    )Zis_positiver   r   r   r   r   Údmp_positive_p…  s    ru   c                 C   s‚   | sg S t |  ¡ ƒg  }}t|tƒrLt|ddƒD ]}| |  ||j¡¡ q0n.|\}t|ddƒD ]}| |  |f|j¡¡ q^t|ƒS )a5  
    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)
    []

    r   )	r.   Úkeysr9   Úintrf   r   Úgetr   r6   ©r	   r
   r_   ÚhÚkr   r   r   Údup_from_dict˜  s    
r|   c                 C   sH   | sg S t |  ¡ ƒg  }}t|ddƒD ]}| |  ||j¡¡ q&t|ƒS )a  
    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]

    r   )r.   rv   rf   r   rx   r   r6   ry   r   r   r   Údup_from_raw_dict¹  s    r}   c                 C   sÔ   |st | |ƒS | st|ƒS i }|  ¡ D ]@\}}|d |dd…  }}||krZ||| |< q&||i||< q&t| ¡ ƒ|d g   }}	}
t|ddƒD ]8}| |¡}|dk	rº|
 t||	|ƒ¡ q�|
 t|	ƒ¡ q�t	|
|ƒS )aF  
    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)
    []

    r   r   Nr   )
r|   r7   Úitemsr.   rv   rf   rx   r   Údmp_from_dictr8   )r	   r   r
   Zcoeffsr   ÚcoeffÚheadÚtailr_   r,   rz   r{   r   r   r   r   Ò  s"    

r   Fc                 C   sZ   | s|rd|j iS t| ƒd i  }}td|d ƒD ]"}| ||  r2| ||  ||f< q2|S )zí
    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([])
    {}

    ©r   r   r   ©r   r   rf   ©r	   r
   r   r_   Úresultr{   r   r   r   Údup_to_dictþ  s    
r‡   c                 C   sX   | s|rd|j iS t| ƒd i  }}td|d ƒD ] }| ||  r2| ||  ||< q2|S )zÓ
    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}

    r   r   r„   r…   r   r   r   Údup_to_raw_dict  s    
rˆ   c                 C   s¢   |st | ||d�S t| |ƒr2|r2d|d  |jiS t| |ƒ|d i   }}}|tkrXd}td|d ƒD ]6}t| ||  |ƒ}| ¡ D ]\}	}
|
||f|	 < q„qf|S )a  
    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   rƒ   r   r   r   )r‡   r!   r   r#   r   rf   Údmp_to_dictr~   )r	   r   r
   r   r_   r,   r†   r{   rz   Úexpr€   r   r   r   r‰   2  s    r‰   c           	      C   s¬   |dk s |dk s ||ks ||kr.t d| ƒ‚n||kr:| S t| |ƒi  }}| ¡ D ]L\}}|||d|… || f ||d |…  || f ||d d…  < qRt|||ƒS )a�  
    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], []]]

    r   z0 <= i < j <= %s expectedNr   )r0   r‰   r~   r   )	r	   r*   r+   r   r
   ÚFÚHrŠ   r€   r   r   r   Údmp_swapU  s     þÿþþr�   c                 C   sd   t | |ƒi  }}| ¡ D ]>\}}dgt|ƒ }t||ƒD ]\}	}
|	||
< q8||t|ƒ< qt|||ƒS )at  
    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], []]]

    r   )r‰   r~   r   Úzipr   r   )r	   ÚPr   r
   r‹   rŒ   rŠ   r€   Znew_expÚeÚpr   r   r   Údmp_permutex  s    
r’   c                 C   s,   t | tƒst| |ƒS t|ƒD ]
}| g} q| S )zè
    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]]]]

    )r9   r:   rk   rf   )r	   Úlr
   r*   r   r   r   Údmp_nest—  s
    

r”   c                    sP   ˆs| S |s2| st ˆƒS ˆd ‰‡fdd„| D ƒS |d ‰‡ ‡‡fdd„| D ƒS )a  
    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]]]]

    r   c                    s   g | ]}t |ˆ ƒ‘qS r   rq   r&   )r{   r   r   rB   Ç  s     zdmp_raise.<locals>.<listcomp>c                    s   g | ]}t |ˆˆˆ ƒ‘qS r   )Ú	dmp_raiser&   )r
   r“   r,   r   r   rB   Ë  s     rm   )r	   r“   r   r
   r   )r
   r{   r“   r,   r   r•   ®  s    r•   c                 C   sj   t | ƒdkrd| fS d}tt| ƒƒD ]2}| | d  s8q$t||ƒ}|dkr$d| f  S q$|| dd|… fS )a  
    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])

    r   r   N)r    rf   r   r   )r	   r
   r/   r*   r   r   r   Údup_deflateÎ  s    
r–   c                 C   sê   t | |ƒrd|d  | fS t| |ƒ}dg|d  }| ¡ D ](}t|ƒD ]\}}t|| |ƒ||< qFq:t|ƒD ]\}}|sld||< qlt|ƒ}tdd„ |D ƒƒr¤|| fS i }	| ¡ D ](\}
}dd„ t|
|ƒD ƒ}||	t|ƒ< q°|t	|	||ƒfS )a5  
    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]])

    )r   r   r   c                 s   s   | ]}|d kV  qdS ©r   Nr   ©r'   Úbr   r   r   r-     s     zdmp_deflate.<locals>.<genexpr>c                 S   s   g | ]\}}|| ‘qS r   r   ©r'   Úar™   r   r   r   rB     s     zdmp_deflate.<locals>.<listcomp>)
r!   r‰   rv   Ú	enumerater   r   Úallr~   rŽ   r   )r	   r   r
   r‹   ÚBÚMr*   Úmr™   rŒ   ÚAr€   rb   r   r   r   Údmp_deflateï  s$    


r¢   c                    s’   d‰ | D ]n}t |ƒdkr$d| f  S d}tt|ƒƒD ]6}|| d  sHq4t||ƒ}|dkr4d| f    S q4tˆ |ƒ‰ qˆ t‡ fdd„| D ƒƒfS )aP  
    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]))

    r   r   c                    s   g | ]}|d d ˆ … ‘qS r$   r   )r'   r‘   ©ÚGr   r   rB   ?  s     z%dup_multi_deflate.<locals>.<listcomp>)r    rf   r   r   r   )Úpolysr
   r‘   r/   r*   r   r£   r   Údup_multi_deflate  s    
r¦   c                 C   s,  |st | |ƒ\}}|f|fS g dg|d   }}| D ]T}t||ƒ}t||ƒs~| ¡ D ](}t|ƒD ]\}	}
t||	 |
ƒ||	< q`qT| |¡ q4t|ƒD ]\}	}|s’d||	< q’t|ƒ}tdd„ |D ƒƒrÊ|| fS g }|D ]L}i }| 	¡ D ](\}}dd„ t
||ƒD ƒ}||t|ƒ< qâ| t|||ƒ¡ qÒ|t|ƒfS )a£  
    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]]))

    r   r   c                 s   s   | ]}|d kV  qdS r—   r   r˜   r   r   r   r-   i  s     z$dmp_multi_deflate.<locals>.<genexpr>c                 S   s   g | ]\}}|| ‘qS r   r   rš   r   r   r   rB   r  s     z%dmp_multi_deflate.<locals>.<listcomp>)r¦   r‰   r!   rv   rœ   r   r   r   r�   r~   rŽ   r   )r¥   r   r
   rŸ   rŒ   r‹   rž   r‘   r	   r*   r    r™   rz   r¡   r€   rb   r   r   r   Údmp_multi_deflateB  s2    



r§   c                 C   sd   |dkrt d| ƒ‚|dks | s$| S | d g}| dd… D ]$}| |jg|d  ¡ | |¡ q:|S )a  
    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]

    r   z'm' must be positive, got %sr   N)r0   Úextendr   r   )r	   r    r
   r†   r€   r   r   r   Údup_inflatez  s    
r©   c                    s¦   |st | ˆ| ˆ ƒS ˆ| dkr0tdˆ|  ƒ‚|d |d  ‰‰‡ ‡‡‡fdd„| D ƒ} | d g}| dd… D ]0}tdˆ| ƒD ]}| tˆƒ¡ q‚| |¡ qp|S )z)Recursive helper for :func:`dmp_inflate`.r   z!all M[i] must be positive, got %sr   c                    s   g | ]}t |ˆˆˆˆ ƒ‘qS r   )Ú_rec_inflater&   ©r
   rŸ   r+   rA   r   r   rB   ¡  s     z _rec_inflate.<locals>.<listcomp>N)r©   r0   rf   r   r7   )r/   rŸ   r,   r*   r
   r†   r€   Ú_r   r«   r   rª   ˜  s    
rª   c                 C   s>   |st | |d |ƒS tdd„ |D ƒƒr*| S t| ||d|ƒS dS )a3  
    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]]

    r   c                 s   s   | ]}|d kV  qdS r—   r   )r'   r    r   r   r   r-   Á  s     zdmp_inflate.<locals>.<genexpr>N)r©   r�   rª   )r	   rŸ   r   r
   r   r   r   Údmp_inflate®  s
    r­   c                 C   sÌ   |rt | d|ƒrg | |fS g t| |ƒ }}td|d ƒD ](}| ¡ D ]}|| rD q8qD| |¡ q8|spg | |fS i } | ¡ D ]0\}}t|ƒ}t|ƒD ]
}||= q”|| t|ƒ< q||t	|ƒ8 }|t
| ||ƒ|fS )a[  
    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)

    Nr   r   )rh   r‰   rf   rv   r   r~   r:   rF   r   r   r   )r	   r   r
   ÚJr‹   r+   r   r€   r   r   r   Údmp_excludeÇ  s$    

r¯   c                 C   sl   |s| S t | |ƒi  }} | ¡ D ]2\}}t|ƒ}|D ]}| |d¡ q4|| t|ƒ< q |t|ƒ7 }t| ||ƒS )a  
    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]]]

    r   )r‰   r~   r:   Úinsertr   r   r   )r	   r®   r   r
   r‹   r   r€   r+   r   r   r   Údmp_include÷  s    r±   c                 C   s‚   t | |ƒi  } }|jd }|  ¡ D ]@\}}| ¡ }| ¡ D ]&\}}	|rT|	||| < q:|	||| < q:q"|| d }
t||
|jƒ|
fS )a¯  
    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)

    r   )r‰   Úngensr~   Úto_dictr   Údom)r	   r   r
   Úfrontrz   r,   Úf_monomr/   Úg_monomr(   rA   r   r   r   Ú
dmp_inject  s    
r¸   c                 C   sÄ   t | |ƒi  } }|j}||j d }|  ¡ D ]h\}}|rT|d|… ||d…  }	}
n|| d… |d| …  }	}
|
|krˆ|||
 |	< q,|	|i||
< q,| ¡ D ]\}}||ƒ||< qžt||d |ƒS )zü
    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]

    r   N)r‰   r²   r~   r   )r	   r   r
   rµ   rz   r_   r,   r   r(   r·   r¶   r   r   r   Ú	dmp_eject>  s    r¹   c                 C   sL   t | |ƒs| sd| fS d}t| ƒD ]}|s4|d7 }q" q:q"|| d| … fS )a  
    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])

    r   r   N)r   rF   )r	   r
   r*   r(   r   r   r   Údup_terms_gcdb  s    
rº   c                 C   sŽ   t | ||ƒst| |ƒr&d|d  | fS t| |ƒ}tt| ¡ ƒŽ }tdd„ |D ƒƒrZ|| fS i } | ¡ D ]\}}|| t||ƒ< qf|t	| ||ƒfS )a$  
    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]])

    rƒ   r   c                 s   s   | ]}|d kV  qdS )r   Nr   )r'   r/   r   r   r   r-   –  s     z dmp_terms_gcd.<locals>.<genexpr>)
r   r!   r‰   r   r:   rv   r�   r~   r   r   )r	   r   r
   r‹   r¤   r   r€   r   r   r   Údmp_terms_gcd€  s    
r»   c              	   C   s€   t | |ƒg  }}|sFt| ƒD ]&\}}|s*q| ||| f |f¡ qn6|d }t| ƒD ]$\}}| t||||| f ƒ¡ qV|S )z,Recursive helper for :func:`dmp_list_terms`.r   )r#   rœ   r   r¨   Ú_rec_list_terms)r/   r,   r   rc   Útermsr*   r(   rA   r   r   r   r¼   ¡  s    r¼   c                 C   sJ   dd„ }t | |dƒ}|s,d|d  |jfgS |dkr8|S ||t|ƒƒS dS )a¸  
    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 | ‡ fdd„dd�S )Nc                    s   ˆ | d ƒS )Nr   r   )Úterm©ÚOr   r   Ú<lambda>Ç  ó    z.dmp_list_terms.<locals>.sort.<locals>.<lambda>T)ÚkeyÚreverse)Úsorted)r½   rÀ   r   r¿   r   ÚsortÆ  s    zdmp_list_terms.<locals>.sortr   rƒ   r   N)r¼   r   r   )r	   r   r
   ÚorderrÆ   r½   r   r   r   Údmp_list_terms´  s    rÈ   c           
      C   s‚   t | ƒt |ƒ }}||krL||kr8|jg||  | }n|jg||  |  } g }t| |ƒD ]\}}	| |||	f|žŽ ¡ qZt|ƒS )a8  
    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   rŽ   r   r6   )
r	   r/   rz   Úargsr
   r_   r    r†   r›   r™   r   r   r   Údup_apply_pairsÔ  s    rÊ   c              
   C   s¤   |st | ||||ƒS t| ƒt|ƒ|d   }}}||krj||krVt|| ||ƒ| }nt|| ||ƒ|  } g }	t| |ƒD ] \}
}|	 t|
|||||ƒ¡ qxt|	|ƒS )aG  
    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]]

    r   )rÊ   r   rp   rŽ   r   Údmp_apply_pairsr8   )r	   r/   rz   rÉ   r   r
   r_   r    r,   r†   r›   r™   r   r   r   rË   ô  s    rË   c                 C   sz   t | ƒ}||kr|| }nd}||kr0|| }nd}| ||… } | r^| d |jkr^|  d¡ q@| sfg S | |jg|  S dS )z=Take a continuous subsequence of terms of ``f`` in ``K[x]``. r   N)r   r   rC   )r	   r    r_   r
   r{   rŸ   rb   r   r   r   Ú	dup_slice  s    

rÌ   c                 C   s   t | ||d||ƒS )z=Take a continuous subsequence of terms of ``f`` in ``K[X]``. r   )Údmp_slice_in)r	   r    r_   r   r
   r   r   r   Ú	dmp_slice/  s    rÎ   c           
      C   s¼   |dk s||kr"t d|||f ƒ‚|s4t| |||ƒS t| |ƒi  } }|  ¡ D ]b\}}|| }	|	|k sl|	|krŒ|d|… d ||d d…  }||kr¦||  |7  < qL|||< qLt|||ƒS )zHTake a continuous subsequence of terms of ``f`` in ``x_j`` in ``K[X]``. r   z-%s <= j < %s expected, got %sNrƒ   r   )r0   rÌ   r‰   r~   r   )
r	   r    r_   r+   r   r
   r/   r   r€   r{   r   r   r   rÍ   4  s     
rÍ   c                    sD   ‡ ‡‡fdd„t d| d ƒD ƒ}|d s@ˆ  t ˆˆ¡¡|d< q |S )a  
    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]

    c                    s   g | ]}ˆ   t ˆˆ¡¡‘qS r   )rU   ÚrandomÚrandint)r'   r¬   ©r
   r›   r™   r   r   rB   Z  s     zdup_random.<locals>.<listcomp>r   r   )rf   rU   rÏ   rÐ   )r_   r›   r™   r
   r	   r   rÑ   r   Ú
dup_randomL  s     rÒ   )N)NF)NF)NF)F)F)N)VÚ__doc__Z
sympy.corer   Zsympy.polys.monomialsr   r   Zsympy.polys.orderingsr   rÏ   Úfloatr   r   r   r   r   r   r   r   r   r   r    r#   r%   r1   r2   r4   r6   r8   r=   r?   rE   rG   rI   rJ   rM   rN   rR   rS   rY   rZ   r\   r]   r`   ra   rd   r!   r7   rj   rl   rh   rk   rp   rs   rt   ru   r|   r}   r   r‡   rˆ   r‰   r�   r’   r”   r•   r–   r¢   r¦   r§   r©   rª   r­   r¯   r±   r¸   r¹   rº   r»   r¼   rÈ   rÊ   rË   rÌ   rÎ   rÍ   rÒ   r   r   r   r   Ú<module>   sœ   
!

 !,


## !,'80"
%
$!
  #