o
    8VaJ                     @   s  d Z ddlmZmZ ddlmZ ddlmZmZm	Z	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mZ ed)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!G d%d& d&Z"eG d'd( d(eZ#d
S )*z@Tools and arithmetics for monomials of distributed polynomials.     )combinations_with_replacementproduct)dedent)MulSTuplesympify)iterable)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public)is_sequenceNc                 #   s   t | }t r?t  |krtddu rdg| nts%tdt |kr/tdtdd D r<tdd}n }|dk rItd	du rPd}n
dk rXtd
}d}|r||kredS | rk|dkrqtjV  dS t| tjg } tdd | D rg }t| |D ].}t	 }	| D ]}
d|	|
< q|D ]}
|
dkr|	|
  d7  < qt
|	 |kr|t|  qt|E dH  dS g }t| |dD ].}t	 }	| D ]}
d|	|
< q|D ]}
|
dkr|	|
  d7  < qt
|	 |kr|t|  qt|E dH  dS t fddt|D rtdg }t|  D ]\}}|fddt||d D  qt| D ]}	t|	 V  q8dS )a  
    ``max_degrees`` and ``min_degrees`` are either both integers or both lists.
    Unless otherwise specified, ``min_degrees`` is either ``0`` or
    ``[0, ..., 0]``.

    A generator of all monomials ``monom`` is returned, such that
    either
    ``min_degree <= total_degree(monom) <= max_degree``,
    or
    ``min_degrees[i] <= degree_list(monom)[i] <= max_degrees[i]``,
    for all ``i``.

    Case I. ``max_degrees`` and ``min_degrees`` are both integers
    =============================================================

    Given a set of variables $V$ and a min_degree $N$ and a max_degree $M$
    generate a set of monomials of degree less than or equal to $N$ and greater
    than or equal to $M$. The total number of monomials in commutative
    variables is huge and is given by the following formula if $M = 0$:

        .. math::
            \frac{(\#V + N)!}{\#V! N!}

    For example if we would like to generate a dense polynomial of
    a total degree $N = 50$ and $M = 0$, which is the worst case, in 5
    variables, assuming that exponents and all of coefficients are 32-bit long
    and stored in an array we would need almost 80 GiB of memory! Fortunately
    most polynomials, that we will encounter, are sparse.

    Consider monomials in commutative variables $x$ and $y$
    and non-commutative variables $a$ and $b$::

        >>> from sympy import symbols
        >>> from sympy.polys.monomials import itermonomials
        >>> from sympy.polys.orderings import monomial_key
        >>> from sympy.abc import x, y

        >>> sorted(itermonomials([x, y], 2), key=monomial_key('grlex', [y, x]))
        [1, x, y, x**2, x*y, y**2]

        >>> sorted(itermonomials([x, y], 3), key=monomial_key('grlex', [y, x]))
        [1, x, y, x**2, x*y, y**2, x**3, x**2*y, x*y**2, y**3]

        >>> a, b = symbols('a, b', commutative=False)
        >>> set(itermonomials([a, b, x], 2))
        {1, a, a**2, b, b**2, x, x**2, a*b, b*a, x*a, x*b}

        >>> sorted(itermonomials([x, y], 2, 1), key=monomial_key('grlex', [y, x]))
        [x, y, x**2, x*y, y**2]

    Case II. ``max_degrees`` and ``min_degrees`` are both lists
    ===========================================================

    If ``max_degrees = [d_1, ..., d_n]`` and
    ``min_degrees = [e_1, ..., e_n]``, the number of monomials generated
    is:

    .. math::
        (d_1 - e_1 + 1) (d_2 - e_2 + 1) \cdots (d_n - e_n + 1)

    Let us generate all monomials ``monom`` in variables $x$ and $y$
    such that ``[1, 2][i] <= degree_list(monom)[i] <= [2, 4][i]``,
    ``i = 0, 1`` ::

        >>> from sympy import symbols
        >>> from sympy.polys.monomials import itermonomials
        >>> from sympy.polys.orderings import monomial_key
        >>> from sympy.abc import x, y

        >>> sorted(itermonomials([x, y], [2, 4], [1, 2]), reverse=True, key=monomial_key('lex', [x, y]))
        [x**2*y**4, x**2*y**3, x**2*y**2, x*y**4, x*y**3, x*y**2]
    zArgument sizes do not matchNr   zmin_degrees is not a listc                 s   s    | ]}|d k V  qdS r   N .0ir   r   7/usr/lib/python3/dist-packages/sympy/polys/monomials.py	<genexpr>c       z itermonomials.<locals>.<genexpr>z*min_degrees can't contain negative numbersFzmax_degrees can't be negativezmin_degrees can't be negativeTc                 s   s    | ]}|j V  qd S N)Zis_commutative)r   variabler   r   r   r   y   s       )repeatc                 3   s     | ]}|  | kV  qd S r   r   r   )max_degreesmin_degreesr   r   r      s    z2min_degrees[i] must be <= max_degrees[i] for all ic                    s   g | ]} | qS r   r   r   )varr   r   
<listcomp>       z!itermonomials.<locals>.<listcomp>)lenr   
ValueErroranyr   ZOnelistallr   dictsumvaluesappendr   setr   rangezip)Z	variablesr   r   nZtotal_degreeZ
max_degreeZ
min_degreeZmonomials_list_commitemZpowersr   Zmonomials_list_non_commZpower_listsZmin_dZmax_dr   )r   r   r   r   itermonomials   s   J

&r.   c                 C   s(   ddl m} || | ||  || S )aW  
    Computes the number of monomials.

    The number of monomials is given by the following formula:

    .. math::

        \frac{(\#V + N)!}{\#V! N!}

    where `N` is a total degree and `V` is a set of variables.

    Examples
    ========

    >>> from sympy.polys.monomials import itermonomials, monomial_count
    >>> from sympy.polys.orderings import monomial_key
    >>> from sympy.abc import x, y

    >>> monomial_count(2, 2)
    6

    >>> M = list(itermonomials([x, y], 2))

    >>> sorted(M, key=monomial_key('grlex', [y, x]))
    [1, x, y, x**2, x*y, y**2]
    >>> len(M)
    6

    r   )	factorial)Zsympyr/   )VNr/   r   r   r   monomial_count   s   r2   c                 C      t dd t| |D S )a%  
    Multiplication of tuples representing monomials.

    Examples
    ========

    Lets multiply `x**3*y**4*z` with `x*y**2`::

        >>> from sympy.polys.monomials import monomial_mul

        >>> monomial_mul((3, 4, 1), (1, 2, 0))
        (4, 6, 1)

    which gives `x**4*y**5*z`.

    c                 S   s   g | ]\}}|| qS r   r   r   abr   r   r   r          z monomial_mul.<locals>.<listcomp>tupler+   ABr   r   r   monomial_mul      r=   c                 C   s(   t | |}tdd |D rt|S dS )a  
    Division of tuples representing monomials.

    Examples
    ========

    Lets divide `x**3*y**4*z` by `x*y**2`::

        >>> from sympy.polys.monomials import monomial_div

        >>> monomial_div((3, 4, 1), (1, 2, 0))
        (2, 2, 1)

    which gives `x**2*y**2*z`. However::

        >>> monomial_div((3, 4, 1), (1, 2, 2)) is None
        True

    `x*y**2*z**2` does not divide `x**3*y**4*z`.

    c                 s   s    | ]}|d kV  qdS r   r   )r   cr   r   r   r      r   zmonomial_div.<locals>.<genexpr>N)monomial_ldivr$   r9   )r;   r<   Cr   r   r   monomial_div   s   
rB   c                 C   r3   )a  
    Division of tuples representing monomials.

    Examples
    ========

    Lets divide `x**3*y**4*z` by `x*y**2`::

        >>> from sympy.polys.monomials import monomial_ldiv

        >>> monomial_ldiv((3, 4, 1), (1, 2, 0))
        (2, 2, 1)

    which gives `x**2*y**2*z`.

        >>> monomial_ldiv((3, 4, 1), (1, 2, 2))
        (2, 2, -1)

    which gives `x**2*y**2*z**-1`.

    c                 S   s   g | ]\}}|| qS r   r   r4   r   r   r   r     r7   z!monomial_ldiv.<locals>.<listcomp>r8   r:   r   r   r   r@      s   r@   c                    s   t  fdd| D S )z%Return the n-th pow of the monomial. c                    s   g | ]}|  qS r   r   r   r5   r,   r   r   r     r   z monomial_pow.<locals>.<listcomp>)r9   )r;   r,   r   rD   r   monomial_pow  s   rE   c                 C   r3   )a.  
    Greatest common divisor of tuples representing monomials.

    Examples
    ========

    Lets compute GCD of `x*y**4*z` and `x**3*y**2`::

        >>> from sympy.polys.monomials import monomial_gcd

        >>> monomial_gcd((1, 4, 1), (3, 2, 0))
        (1, 2, 0)

    which gives `x*y**2`.

    c                 S      g | ]	\}}t ||qS r   )minr4   r   r   r   r         z monomial_gcd.<locals>.<listcomp>r8   r:   r   r   r   monomial_gcd  r>   rI   c                 C   r3   )a1  
    Least common multiple of tuples representing monomials.

    Examples
    ========

    Lets compute LCM of `x*y**4*z` and `x**3*y**2`::

        >>> from sympy.polys.monomials import monomial_lcm

        >>> monomial_lcm((1, 4, 1), (3, 2, 0))
        (3, 4, 1)

    which gives `x**3*y**4*z`.

    c                 S   rF   r   )maxr4   r   r   r   r   +  rH   z monomial_lcm.<locals>.<listcomp>r8   r:   r   r   r   monomial_lcm  r>   rK   c                 C   r3   )z
    Does there exist a monomial X such that XA == B?

    Examples
    ========

    >>> from sympy.polys.monomials import monomial_divides
    >>> monomial_divides((1, 2), (3, 4))
    True
    >>> monomial_divides((1, 2), (0, 2))
    False
    c                 s   s    | ]	\}}||kV  qd S r   r   r4   r   r   r   r   :  s    z#monomial_divides.<locals>.<genexpr>)r$   r+   r:   r   r   r   monomial_divides-  s   rL   c                  G   J   t | d }| dd D ]}t|D ]\}}t|| |||< qqt|S )a  
    Returns maximal degree for each variable in a set of monomials.

    Examples
    ========

    Consider monomials `x**3*y**4*z**5`, `y**5*z` and `x**6*y**3*z**9`.
    We wish to find out what is the maximal degree for each of `x`, `y`
    and `z` variables::

        >>> from sympy.polys.monomials import monomial_max

        >>> monomial_max((3,4,5), (0,5,1), (6,3,9))
        (6, 5, 9)

    r   r   N)r#   	enumeraterJ   r9   ZmonomsMr1   r   r,   r   r   r   monomial_max<     rQ   c                  G   rM   )a  
    Returns minimal degree for each variable in a set of monomials.

    Examples
    ========

    Consider monomials `x**3*y**4*z**5`, `y**5*z` and `x**6*y**3*z**9`.
    We wish to find out what is the minimal degree for each of `x`, `y`
    and `z` variables::

        >>> from sympy.polys.monomials import monomial_min

        >>> monomial_min((3,4,5), (0,5,1), (6,3,9))
        (0, 3, 1)

    r   r   N)r#   rN   rG   r9   rO   r   r   r   monomial_minU  rR   rS   c                 C   s   t | S )z
    Returns the total degree of a monomial.

    Examples
    ========

    The total degree of `xy^2` is 3:

    >>> from sympy.polys.monomials import monomial_deg
    >>> monomial_deg((1, 2))
    3
    )r&   )rP   r   r   r   monomial_degn  s   rT   c                 C   s`   | \}}|\}}t ||}|jr|dur||||fS dS |du s.|| s.||||fS dS )z,Division of two terms in over a ring/field. N)rB   Zis_FieldZquo)r5   r6   domainZa_lmZa_lcZb_lmZb_lcmonomr   r   r   term_div}  s   
rW   c                   @   s`   e Zd Z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S )MonomialOpsz6Code generator of fast monomial arithmetic functions. c                 C   s
   || _ d S r   )ngens)selfrY   r   r   r   __init__     
zMonomialOps.__init__c                 C   s   i }t || || S r   )exec)rZ   codenamensr   r   r   _build  s   
zMonomialOps._buildc                    s    fddt | jD S )Nc                    s   g | ]}d  |f qS )z%s%sr   r   r_   r   r   r     r7   z%MonomialOps._vars.<locals>.<listcomp>)r*   rY   )rZ   r_   r   rb   r   _vars  s   zMonomialOps._varsc                 C   f   d}t d}| d}| d}dd t||D }|t|d|d|d|d }| ||S )	Nr=   s        def %(name)s(A, B):
            (%(A)s,) = A
            (%(B)s,) = B
            return (%(AB)s,)
        r5   r6   c                 S      g | ]
\}}d ||f qS )z%s + %sr   r4   r   r   r   r         z#MonomialOps.mul.<locals>.<listcomp>, r_   r;   r<   ABr   rc   r+   r%   joinra   rZ   r_   templater;   r<   rj   r^   r   r   r   mul     

&zMonomialOps.mulc                 C   sN   d}t d}| d}dd |D }|t|d|d|d }| ||S )NrE   zZ        def %(name)s(A, k):
            (%(A)s,) = A
            return (%(Ak)s,)
        r5   c                 S   s   g | ]}d | qS )z%s*kr   rC   r   r   r   r     r   z#MonomialOps.pow.<locals>.<listcomp>rh   )r_   r;   Ak)r   rc   r%   rl   ra   )rZ   r_   rn   r;   rq   r^   r   r   r   pow  s   
zMonomialOps.powc                 C   rd   )	NZmonomial_mulpowzw        def %(name)s(A, B, k):
            (%(A)s,) = A
            (%(B)s,) = B
            return (%(ABk)s,)
        r5   r6   c                 S   rf   )z	%s + %s*kr   r4   r   r   r   r     rg   z&MonomialOps.mulpow.<locals>.<listcomp>rh   )r_   r;   r<   ABkrk   )rZ   r_   rn   r;   r<   rs   r^   r   r   r   mulpow  rp   zMonomialOps.mulpowc                 C   rd   )	Nr@   re   r5   r6   c                 S   rf   )z%s - %sr   r4   r   r   r   r     rg   z$MonomialOps.ldiv.<locals>.<listcomp>rh   ri   rk   rm   r   r   r   ldiv  rp   zMonomialOps.ldivc              	   C   sx   d}t d}| d}| d}dd t| jD }| d}|t|d|d|d	|d|d
 }| ||S )NrB   z        def %(name)s(A, B):
            (%(A)s,) = A
            (%(B)s,) = B
            %(RAB)s
            return (%(R)s,)
        r5   r6   c                 S   s   g | ]	}d t |d qS )z7r%(i)s = a%(i)s - b%(i)s
    if r%(i)s < 0: return None)r   )r%   r   r   r   r   r     rH   z#MonomialOps.div.<locals>.<listcomp>rrh   z
    )r_   r;   r<   RABR)r   rc   r*   rY   r%   rl   ra   )rZ   r_   rn   r;   r<   rw   rx   r^   r   r   r   div  s   


.zMonomialOps.divc                 C   rd   )	NrK   re   r5   r6   c                 S       g | ]\}}d ||||f qS )z%s if %s >= %s else %sr   r4   r   r   r   r          z#MonomialOps.lcm.<locals>.<listcomp>rh   ri   rk   rm   r   r   r   lcm  rp   zMonomialOps.lcmc                 C   rd   )	NrI   re   r5   r6   c                 S   rz   )z%s if %s <= %s else %sr   r4   r   r   r   r     r{   z#MonomialOps.gcd.<locals>.<listcomp>rh   ri   rk   rm   r   r   r   gcd  rp   zMonomialOps.gcdN)__name__
__module____qualname____doc__r[   ra   rc   ro   rr   rt   ru   ry   r|   r}   r   r   r   r   rX     s    rX   c                   @   s   e Zd ZdZdZd"ddZd"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eZdd Zdd Zd d! ZdS )#Monomialz9Class representing a monomial, i.e. a product of powers. )	exponentsgensNc                 C   sv   t |s.tt||d\}}t|dkr't| d dkr't| d }ntd|t	t
t|| _|| _d S )N)r   r   r   zExpected a monomial got {})r	   r   r   r    r#   r'   keysr!   formatr9   mapintr   r   )rZ   rV   r   Zrepr   r   r   r[     s    
zMonomial.__init__c                 C   s   |  ||p| jS r   )	__class__r   )rZ   r   r   r   r   r   rebuild  s   zMonomial.rebuildc                 C   
   t | jS r   )r    r   rZ   r   r   r   __len__  r\   zMonomial.__len__c                 C   r   r   )iterr   r   r   r   r   __iter__  r\   zMonomial.__iter__c                 C   s
   | j | S r   )r   )rZ   r-   r   r   r   __getitem__  r\   zMonomial.__getitem__c                 C   s   t | jj| j| jfS r   )hashr   r~   r   r   r   r   r   r   __hash__  s   zMonomial.__hash__c                 C   s6   | j rddd t| j | jD S d| jj| jf S )N*c                 S   rf   )z%s**%sr   r   genZexpr   r   r   r   !  rg   z$Monomial.__str__.<locals>.<listcomp>z%s(%s))r   rl   r+   r   r   r~   r   r   r   r   __str__  s   zMonomial.__str__c                 G   s4   |p| j }|std|  tdd t|| jD  S )z3Convert a monomial instance to a SymPy expression. z4can't convert %s to an expression without generatorsc                 S   s   g | ]\}}|| qS r   r   r   r   r   r   r   -  r7   z$Monomial.as_expr.<locals>.<listcomp>)r   r!   r   r+   r   )rZ   r   r   r   r   as_expr%  s   
zMonomial.as_exprc                 C   s4   t |tr	|j}nt |ttfr|}ndS | j|kS )NF)
isinstancer   r   r9   r   rZ   otherr   r   r   r   __eq__/  s   

zMonomial.__eq__c                 C   s
   | |k S r   r   )rZ   r   r   r   r   __ne__9  r\   zMonomial.__ne__c                 C   s<   t |tr	|j}nt |ttfr|}nt| t| j|S r   )r   r   r   r9   r   NotImplementedErrorr   r=   r   r   r   r   __mul__<  s   
zMonomial.__mul__c                 C   sV   t |tr	|j}nt |ttfr|}ntt| j|}|d ur$| |S t| t|r   )	r   r   r   r9   r   r   rB   r   r
   )rZ   r   r   resultr   r   r   __truediv__F  s   

zMonomial.__truediv__c                 C   s`   t |}|s| dgt|  S |dkr*| j}td|D ]}t|| j}q| |S td| )Nr   r   z'a non-negative integer expected, got %s)r   r   r    r   r*   r=   r!   )rZ   r   r,   r   r   r   r   r   __pow__W  s   
zMonomial.__pow__c                 C   D   t |tr	|j}nt |ttfr|}ntd| | t| j|S )z&Greatest common divisor of monomials. .an instance of Monomial class expected, got %s)r   r   r   r9   r   	TypeErrorr   rI   r   r   r   r   r}   f     
zMonomial.gcdc                 C   r   )z$Least common multiple of monomials. r   )r   r   r   r9   r   r   r   rK   r   r   r   r   r|   r  r   zMonomial.lcmr   )r~   r   r   r   	__slots__r[   r   r   r   r   r   r   r   r   r   r   r   __floordiv__r   r}   r|   r   r   r   r   r     s&    




r   r   )$r   	itertoolsr   r   textwrapr   Z
sympy.corer   r   r   r   Zsympy.core.compatibilityr	   Zsympy.polys.polyerrorsr
   Zsympy.polys.polyutilsr   r   Zsympy.utilitiesr   r   r.   r2   r=   rB   r@   rE   rI   rK   rL   rQ   rS   rT   rW   rX   r   r   r   r   r   <module>   s6     !p