a
    <b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mZ ddlmZ ddlmZ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)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public)is_sequenceiterableNc                 #   s  t | }t r~t  |kr$tddu r8dg| n@tsJtdn.t |kr^tdtdd D rxtdd}n: }|dk rtd	du rd}ndk rtd
}d}|r||krdS | r|dkrtjV  dS t| tjg } tdd | D rg }t| |D ]f}t	 }	| D ]}
d|	|
< q"|D ] }
|
dkr6|	|
  d7  < q6t
|	 |kr|t|  qt|E dH  ng }t| |dD ]f}t	 }	| D ]}
d|	|
< q|D ] }
|
dkr|	|
  d7  < qt
|	 |kr|t|  qt|E dH  nt fddt|D r:tdg }t|  D ].\}}|fddt||d D  qJt| D ]}	t|	 V  qd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   e/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/polys/monomials.py	<genexpr>b       z itermonomials.<locals>.<genexpr>z+min_degrees cannot contain negative numbersFzmax_degrees cannot be negativezmin_degrees cannot be negativeTc                 s   s   | ]}|j V  qd S N)Zis_commutative)r   variabler   r   r   r   x   r      )repeatc                 3   s   | ]}|  | kV  qd S r   r   r   )max_degreesmin_degreesr   r   r      r   z2min_degrees[i] must be <= max_degrees[i] for all ic                    s   g | ]} | qS r   r   r   )varr   r   
<listcomp>   r   z!itermonomials.<locals>.<listcomp>)lenr   
ValueErroranyr   ZOnelistallr   dictsumvaluesappendr   setr   rangezip)	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   sv    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(sympy.functions.combinatorial.factorialsr/   )VNr/   r   r   r   monomial_count   s    r2   c                 C   s   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      r   z monomial_mul.<locals>.<listcomp>tupler*   ABr   r   r   monomial_mul   s    r;   c                 C   s,   t | |}tdd |D r$t|S d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#   r7   )r9   r:   Cr   r   r   monomial_div   s    
r?   c                 C   s   t dd t| |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_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   r3   r   r   r   r      r   z!monomial_ldiv.<locals>.<listcomp>r6   r8   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   r4   r,   r   r   r     r   z monomial_pow.<locals>.<listcomp>)r7   )r9   r,   r   rA   r   monomial_pow  s    rB   c                 C   s   t dd t| |D S )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   s   g | ]\}}t ||qS r   )minr3   r   r   r   r     r   z monomial_gcd.<locals>.<listcomp>r6   r8   r   r   r   monomial_gcd  s    rD   c                 C   s   t dd t| |D S )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   s   g | ]\}}t ||qS r   )maxr3   r   r   r   r   *  r   z monomial_lcm.<locals>.<listcomp>r6   r8   r   r   r   monomial_lcm  s    rF   c                 C   s   t dd t| |D S )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   r3   r   r   r   r   9  r   z#monomial_divides.<locals>.<genexpr>)r#   r*   r8   r   r   r   monomial_divides,  s    rG   c                  G   sJ   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"   	enumeraterE   r7   ZmonomsMr1   r   r,   r   r   r   monomial_max;  s
    rK   c                  G   sJ   t | d }| dd D ](}t|D ]\}}t|| |||< q$qt|S )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"   rH   rC   r7   rI   r   r   r   monomial_minT  s
    rL   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%   )rJ   r   r   r   monomial_degm  s    rM   c                 C   sf   | \}}|\}}t ||}|jr>|dur8||||fS dS n$|du s^|| s^||||fS dS dS )z,Division of two terms in over a ring/field. N)r?   Zis_FieldZquo)r4   r5   domainZa_lmZa_lcZb_lmZb_lcmonomr   r   r   term_div|  s    
rP   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)selfrR   r   r   r   __init__  s    zMonomialOps.__init__c                 C   s   i }t || || S r   )exec)rS   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   rW   r   r   r     r   z%MonomialOps._vars.<locals>.<listcomp>)r)   rR   )rS   rW   r   rZ   r   _vars  s    zMonomialOps._varsc                 C   sf   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,)
        r4   r5   c                 S   s   g | ]\}}d ||f qS )z%s + %sr   r3   r   r   r   r     r   z#MonomialOps.mul.<locals>.<listcomp>, rW   r9   r:   ABr   r[   r*   r$   joinrY   rS   rW   templater9   r:   r_   rV   r   r   r   mul  s    

&zMonomialOps.mulc                 C   sN   d}t d}| d}dd |D }|t|d|d|d }| ||S )NrB   zZ        def %(name)s(A, k):
            (%(A)s,) = A
            return (%(Ak)s,)
        r4   c                 S   s   g | ]}d | qS )z%s*kr   r@   r   r   r   r     r   z#MonomialOps.pow.<locals>.<listcomp>r]   )rW   r9   Ak)r   r[   r$   ra   rY   )rS   rW   rc   r9   re   rV   r   r   r   pow  s    
zMonomialOps.powc                 C   sf   d}t d}| d}| d}dd t||D }|t|d|d|d|d }| ||S )	NZmonomial_mulpowzw        def %(name)s(A, B, k):
            (%(A)s,) = A
            (%(B)s,) = B
            return (%(ABk)s,)
        r4   r5   c                 S   s   g | ]\}}d ||f qS )z	%s + %s*kr   r3   r   r   r   r     r   z&MonomialOps.mulpow.<locals>.<listcomp>r]   )rW   r9   r:   ABkr`   )rS   rW   rc   r9   r:   rg   rV   r   r   r   mulpow  s    

&zMonomialOps.mulpowc                 C   sf   d}t d}| d}| d}dd t||D }|t|d|d|d|d }| ||S )	Nr=   r\   r4   r5   c                 S   s   g | ]\}}d ||f qS )z%s - %sr   r3   r   r   r   r     r   z$MonomialOps.ldiv.<locals>.<listcomp>r]   r^   r`   rb   r   r   r   ldiv  s    

&zMonomialOps.ldivc              	   C   sx   d}t d}| d}| d}dd t| jD }| d}|t|d|d|d	|d|d
 }| ||S )Nr?   z        def %(name)s(A, B):
            (%(A)s,) = A
            (%(B)s,) = B
            %(RAB)s
            return (%(R)s,)
        r4   r5   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     r   z#MonomialOps.div.<locals>.<listcomp>rr]   z
    )rW   r9   r:   RABR)r   r[   r)   rR   r$   ra   rY   )rS   rW   rc   r9   r:   rk   rl   rV   r   r   r   div  s    


.zMonomialOps.divc                 C   sf   d}t d}| d}| d}dd t||D }|t|d|d|d|d }| ||S )	NrF   r\   r4   r5   c                 S   s    g | ]\}}d ||||f qS )z%s if %s >= %s else %sr   r3   r   r   r   r     r   z#MonomialOps.lcm.<locals>.<listcomp>r]   r^   r`   rb   r   r   r   lcm  s    

&zMonomialOps.lcmc                 C   sf   d}t d}| d}| d}dd t||D }|t|d|d|d|d }| ||S )	NrD   r\   r4   r5   c                 S   s    g | ]\}}d ||||f qS )z%s if %s <= %s else %sr   r3   r   r   r   r     r   z#MonomialOps.gcd.<locals>.<listcomp>r]   r^   r`   rb   r   r   r   gcd  s    

&zMonomialOps.gcdN)__name__
__module____qualname____doc__rT   rY   r[   rd   rf   rh   ri   rm   rn   ro   r   r   r   r   rQ     s   rQ   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rNt| d dkrNt| d }ntd|t	t
t|| _|| _d S )N)rv   r   r   zExpected a monomial got {})r   r   r   r   r"   r&   keysr    formatr7   mapintru   rv   )rS   rO   rv   repr   r   r   rT     s     zMonomial.__init__c                 C   s   |  ||p| jS r   )	__class__rv   )rS   ru   rv   r   r   r   rebuild  s    zMonomial.rebuildc                 C   s
   t | jS r   )r   ru   rS   r   r   r   __len__  s    zMonomial.__len__c                 C   s
   t | jS r   )iterru   r~   r   r   r   __iter__  s    zMonomial.__iter__c                 C   s
   | j | S r   )ru   )rS   r-   r   r   r   __getitem__  s    zMonomial.__getitem__c                 C   s   t | jj| j| jfS r   )hashr|   rp   ru   rv   r~   r   r   r   __hash__  s    zMonomial.__hash__c                 C   s:   | j r$ddd t| j | jD S d| jj| jf S d S )N*c                 S   s   g | ]\}}d ||f qS )z%s**%sr   r   genexpr   r   r   r      r   z$Monomial.__str__.<locals>.<listcomp>z%s(%s))rv   ra   r*   ru   r|   rp   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. z5Cannot convert %s to an expression without generatorsc                 S   s   g | ]\}}|| qS r   r   r   r   r   r   r   ,  r   z$Monomial.as_expr.<locals>.<listcomp>)rv   r    r   r*   ru   )rS   rv   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)
isinstancert   ru   r7   r   rS   otherru   r   r   r   __eq__.  s    
zMonomial.__eq__c                 C   s
   | |k S r   r   )rS   r   r   r   r   __ne__8  s    zMonomial.__ne__c                 C   s<   t |tr|j}nt |ttfr&|}nt| t| j|S r   )r   rt   ru   r7   r   NotImplementedErrorr}   r;   r   r   r   r   __mul__;  s    
zMonomial.__mul__c                 C   sZ   t |tr|j}nt |ttfr&|}ntt| j|}|d urH| |S t| t|d S r   )	r   rt   ru   r7   r   r   r?   r}   r	   )rS   r   ru   resultr   r   r   __truediv__E  s    

zMonomial.__truediv__c                 C   sd   t |}|s | dgt|  S |dkrT| j}td|D ]}t|| j}q8| |S td| d S )Nr   r   z'a non-negative integer expected, got %s)rz   r}   r   ru   r)   r;   r    )rS   r   r,   ru   r   r   r   r   __pow__V  s    
zMonomial.__pow__c                 C   sD   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   rt   ru   r7   r   	TypeErrorr}   rD   r   r   r   r   ro   e  s    
zMonomial.gcdc                 C   sD   t |tr|j}n t |ttfr&|}ntd| | t| j|S )z$Least common multiple of monomials. r   )r   rt   ru   r7   r   r   r}   rF   r   r   r   r   rn   q  s    
zMonomial.lcm)N)N)rp   rq   rr   rs   	__slots__rT   r}   r   r   r   r   r   r   r   r   r   r   __floordiv__r   ro   rn   r   r   r   r   rt     s$   




rt   )N)$rs   	itertoolsr   r   textwrapr   Z
sympy.corer   r   r   r   Zsympy.polys.polyerrorsr	   Zsympy.polys.polyutilsr
   r   Zsympy.utilitiesr   Zsympy.utilities.iterablesr   r   r.   r2   r;   r?   r=   rB   rD   rF   rG   rK   rL   rM   rP   rQ   rt   r   r   r   r   <module>   s2    !p