o
    8Vav                     @   s   d Z ddl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mZ d
d Zdd Zdd ZG dd dZe Zdd ZG dd deZd(ddZdd Zd)ddZdd Zd*dd Zd+d"d#Zd$d% Zd&d' ZdS ),z"
Generating and counting primes.

    N)bisectcount)array)FunctionS)as_int   )isprimec                 C   s   t ddg|  S )Nlr   _arrayn r   8/usr/lib/python3/dist-packages/sympy/ntheory/generate.py_azeros      r   c                  G   s
   t d| S Nr   r   )vr   r   r   _aset   s   
r   c                 C   s   t dt| |S r   )r   range)abr   r   r   _arange   r   r   c                   @   st   e Zd ZdZdd Zdd Zd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d Zdd ZdS )Sievea  An infinite list of prime numbers, implemented as a dynamically
    growing sieve of Eratosthenes. When a lookup is requested involving
    an odd number that has not been sieved, the sieve is automatically
    extended up to that number.

    Examples
    ========

    >>> from sympy import sieve
    >>> sieve._reset() # this line for doctest only
    >>> 25 in sieve
    False
    >>> sieve._list
    array('l', [2, 3, 5, 7, 11, 13, 17, 19, 23])
    c                    sl   d _ tdddddd _tdd	d	ddd
 _tdd	dddd _t fdd j j jfD s4J d S )N                     r   r	      c                 3   s    | ]
}t | jkV  qd S N)len_n.0iselfr   r   	<genexpr>5   s    z!Sieve.__init__.<locals>.<genexpr>)r'   r   _list_tlist_mlistallr+   r   r+   r   __init__0   s
   *zSieve.__init__c                 C   s   ddt | j| jd | jd | jd | jd | jd dt | j| jd | jd | jd | jd | jd d	t | j| jd | jd | jd | jd | jd f S )
Nzs<%s sieve (%i): %i, %i, %i, ... %i, %i
%s sieve (%i): %i, %i, %i, ... %i, %i
%s sieve (%i): %i, %i, %i, ... %i, %i>primer   r	   r   r$   totientmobius)r&   r.   r/   r0   r+   r   r   r   __repr__7   s   


zSieve.__repr__Nc                 C   sn   t dd |||fD rd } }}|r| jd| j | _|r(| jd| j | _|r5| jd| j | _dS dS )z]Reset all caches (default). To reset one or more set the
            desired keyword to True.c                 s   s    | ]}|d u V  qd S r%   r   r(   r   r   r   r-   H   s    zSieve._reset.<locals>.<genexpr>TN)r1   r.   r'   r/   r0   )r,   r3   r5   r6   r   r   r   _resetE   s   zSieve._resetc                 C   s   t |}|| jd krdS t |d d }| | | jd d }t||d }| |D ]}| | }t|t||D ]}d||< q<q-|  jtddd |D 7  _dS )	a  Grow the sieve to cover all primes <= n (a real number).

        Examples
        ========

        >>> from sympy import sieve
        >>> sieve._reset() # this line for doctest only
        >>> sieve.extend(30)
        >>> sieve[10] == 29
        True
        r$   N      ?r	   r   r   c                 S   s   g | ]}|r|qS r   r   )r)   xr   r   r   
<listcomp>t   s    z Sieve.extend.<locals>.<listcomp>)intr.   extendr   
primeranger   r&   r   )r,   r   ZmaxbaseZbeginZnewsievep
startindexr*   r   r   r   r=   Q   s   


"zSieve.extendc                 C   sD   t |}t| j|k r | t| jd d  t| j|k sdS dS )a  Extend to include the ith prime number.

        Parameters
        ==========

        i : integer

        Examples
        ========

        >>> from sympy import sieve
        >>> sieve._reset() # this line for doctest only
        >>> sieve.extend_to_no(9)
        >>> sieve._list
        array('l', [2, 3, 5, 7, 11, 13, 17, 19, 23])

        Notes
        =====

        The list is extended by 50% if it is too short, so it is
        likely that it will be longer than requested.
        r$   g      ?N)r   r&   r.   r=   r<   )r,   r*   r   r   r   extend_to_nov   s   zSieve.extend_to_noc                 c   s    ddl m} |du rt||}d}ntdt||}t||}||kr)dS | | | |d }t| jd }||k r[| j|d  }||k rS|V  |d7 }ndS ||k s@dS dS )a(  Generate all prime numbers in the range [2, a) or [a, b).

        Examples
        ========

        >>> from sympy import sieve, prime

        All primes less than 19:

        >>> print([i for i in sieve.primerange(19)])
        [2, 3, 5, 7, 11, 13, 17]

        All primes greater than or equal to 7 and less than 19:

        >>> print([i for i in sieve.primerange(7, 19)])
        [7, 11, 13, 17]

        All primes through the 10th prime

        >>> list(sieve.primerange(prime(10) + 1))
        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

        r   ceilingNr   r	   )#sympy.functions.elementary.integersrC   r   maxr=   searchr&   r.   )r,   r   r   rC   r*   Zmaxir?   r   r   r   r>      s&   

zSieve.primerangec           	      c   s2   ddl m} tdt||}t||}t| j}||kr!dS ||kr5t||D ]}| j| V  q*dS |  jt||7  _td|D ]*}| j| }|| d | | }t|||D ]}| j|  |8  < q[||krn|V  qDt||D ]"}| j| }td| ||D ]}| j|  |8  < q||kr|V  qtdS )zGenerate all totient numbers for the range [a, b).

        Examples
        ========

        >>> from sympy import sieve
        >>> print([i for i in sieve.totientrange(7, 18)])
        [6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16]
        r   rB   r	   Nr   )rD   rC   rE   r   r&   r/   r   r   )	r,   r   r   rC   r   r*   Ztir@   jr   r   r   totientrange   s8   



zSieve.totientrangec           	      c   s4   ddl m} tdt||}t||}t| j}||kr!dS ||kr5t||D ]}| j| V  q*dS |  jt|| 7  _td|D ]*}| j| }|| d | | }t|||D ]}| j|  |8  < q\||kro|V  qEt||D ]"}| j| }td| ||D ]}| j|  |8  < q||kr|V  qudS )a  Generate all mobius numbers for the range [a, b).

        Parameters
        ==========

        a : integer
            First number in range

        b : integer
            First number outside of range

        Examples
        ========

        >>> from sympy import sieve
        >>> print([i for i in sieve.mobiusrange(7, 18)])
        [-1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1]
        r   rB   r	   Nr   )rD   rC   rE   r   r&   r0   r   r   )	r,   r   r   rC   r   r*   mir@   rG   r   r   r   mobiusrange   s8   


zSieve.mobiusrangec                 C   s~   ddl m} t||}t|}|dk rtd| || jd kr&| | t| j|}| j|d  |kr9||fS ||d fS )a~  Return the indices i, j of the primes that bound n.

        If n is prime then i == j.

        Although n can be an expression, if ceiling cannot convert
        it to an integer then an n error will be raised.

        Examples
        ========

        >>> from sympy import sieve
        >>> sieve.search(25)
        (9, 10)
        >>> sieve.search(23)
        (9, 9)
        r   rB   r   zn should be >= 2 but got: %sr$   r	   )rD   rC   r   
ValueErrorr.   r=   r   )r,   r   rC   testr   r   r   r   rF     s   
zSieve.searchc              	   C   s\   zt |}|dksJ W n ttfy   Y dS w |d dkr#|dkS | |\}}||kS )Nr   Fr   )r   rK   AssertionErrorrF   )r,   r   r   r   r   r   r   __contains__8  s   zSieve.__contains__c                 c   s    t dD ]}| | V  qd S )Nr	   r   )r,   r   r   r   r   __iter__C  s   zSieve.__iter__c                 C   s   t |tr+| |j |jdur|jnd}|dk rtd| j|d |jd |j S |dk r3tdt|}| | | j|d  S )zReturn the nth prime numberNr   r	   zSieve indices start at 1.)	
isinstanceslicerA   stopstart
IndexErrorr.   stepr   )r,   r   rS   r   r   r   __getitem__G  s   

zSieve.__getitem__)NNNr%   )__name__
__module____qualname____doc__r2   r7   r8   r=   rA   r>   rH   rJ   rF   rN   rO   rV   r   r   r   r   r      s    
%
/'0!r   c                 C   s   t | }|dk rtd|ttjkrt| S ddlm} ddlm} d}t	||||||  }||k rN|| d? }|||krF|}n|d }||k s7t
|d }||k rht|r`|d7 }|d7 }||k sX|d S )aD   Return the nth prime, with the primes indexed as prime(1) = 2,
        prime(2) = 3, etc.... The nth prime is approximately n*log(n).

        Logarithmic integral of x is a pretty nice approximation for number of
        primes <= x, i.e.
        li(x) ~ pi(x)
        In fact, for the numbers we are concerned about( x<1e11 ),
        li(x) - pi(x) < 50000

        Also,
        li(x) > pi(x) can be safely assumed for the numbers which
        can be evaluated by this function.

        Here, we find the least integer m such that li(m) > n using binary search.
        Now pi(m-1) < li(m-1) <= n,

        We find pi(m - 1) using primepi function.

        Starting from m, we have to find n - pi(m-1) more primes.

        For the inputs this implementation can handle, we will have to test
        primality for at max about 10**5 numbers, to get our answer.

        Examples
        ========

        >>> from sympy import prime
        >>> prime(10)
        29
        >>> prime(1)
        2
        >>> prime(100000)
        1299709

        See Also
        ========

        sympy.ntheory.primetest.isprime : Test if n is prime
        primerange : Generate all primes in a given range
        primepi : Return the number of primes less than or equal to n

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Prime_number_theorem#Table_of_.CF.80.28x.29.2C_x_.2F_log_x.2C_and_li.28x.29
        .. [2] https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number
        .. [3] https://en.wikipedia.org/wiki/Skewes%27_number
    r	   z-nth must be a positive integer; prime(1) == 2r   lilogr   )r   rK   r&   siever.   'sympy.functions.special.error_functionsr\   &sympy.functions.elementary.exponentialr^   r<   primepir
   )nthr   r\   r^   r   r   midZn_primesr   r   r   r3   `  s,   1r3   c                   @   s   e Zd ZdZedd ZdS )rb   aH	   Represents the prime counting function pi(n) = the number
        of prime numbers less than or equal to n.

        Algorithm Description:

        In sieve method, we remove all multiples of prime p
        except p itself.

        Let phi(i,j) be the number of integers 2 <= k <= i
        which remain after sieving from primes less than
        or equal to j.
        Clearly, pi(n) = phi(n, sqrt(n))

        If j is not a prime,
        phi(i,j) = phi(i, j - 1)

        if j is a prime,
        We remove all numbers(except j) whose
        smallest prime factor is j.

        Let x= j*a be such a number, where 2 <= a<= i / j
        Now, after sieving from primes <= j - 1,
        a must remain
        (because x, and hence a has no prime factor <= j - 1)
        Clearly, there are phi(i / j, j - 1) such a
        which remain on sieving from primes <= j - 1

        Now, if a is a prime less than equal to j - 1,
        x= j*a has smallest prime factor = a, and
        has already been removed(by sieving from a).
        So, we don't need to remove it again.
        (Note: there will be pi(j - 1) such x)

        Thus, number of x, that will be removed are:
        phi(i / j, j - 1) - phi(j - 1, j - 1)
        (Note that pi(j - 1) = phi(j - 1, j - 1))

        => phi(i,j) = phi(i, j - 1) - phi(i / j, j - 1) + phi(j - 1, j - 1)

        So,following recursion is used and implemented as dp:

        phi(a, b) = phi(a, b - 1), if b is not a prime
        phi(a, b) = phi(a, b-1)-phi(a / b, b-1) + phi(b-1, b-1), if b is prime

        Clearly a is always of the form floor(n / k),
        which can take at most 2*sqrt(n) values.
        Two arrays arr1,arr2 are maintained
        arr1[i] = phi(i, j),
        arr2[i] = phi(n // i, j)

        Finally the answer is arr2[1]

        Examples
        ========

        >>> from sympy import primepi, prime, prevprime, isprime
        >>> primepi(25)
        9

        So there are 9 primes less than or equal to 25. Is 25 prime?

        >>> isprime(25)
        False

        It isn't. So the first prime less than 25 must be the
        9th prime:

        >>> prevprime(25) == prime(9)
        True

        See Also
        ========

        sympy.ntheory.primetest.isprime : Test if n is prime
        primerange : Generate all primes in a given range
        prime : Return the nth prime
    c           
      C   s  |t ju rt jS |t ju rt jS zt|}W n ty.   |jdks'|t ju r+tdY d S w |dk r6t jS |t	j
d krFt t	|d S t|d }|d8 }t|d}|| |kre|d7 }|| |ks[|d8 }dg|d  }dg|d  }td|d D ]}|d ||< || d ||< q~td|d D ]g}|| ||d  krq||d  }tdt|||  |d D ]%}|| }||kr||  || | 8  < q||  |||  | 8  < qt||| d }	t||	dD ]}||  |||  | 8  < qqt |d S )NFzn must be realr   r$   r   r9   r	   )r   ZInfinityZNegativeInfinityZZeror<   	TypeErrorZis_realZNaNrK   r_   r.   rF   rE   r   min)
clsr   ZlimZarr1Zarr2r*   r?   rG   stZlim2r   r   r   eval  sR   


 zprimepi.evalN)rW   rX   rY   rZ   classmethodri   r   r   r   r   rb     s    Mrb   c                 C   s2  t | } t|}|dkr!| }d}	 t|}|d7 }||kr 	 |S q| dk r'dS | dk r5dddddd|  S | tjd krQt| \}}||krMt|d  S t| S d| d  }|| krj| d7 } t| re| S | d	7 } n| | dkr| d7 } t| rz| S | d	7 } n|d } 	 t| r| S | d7 } t| r| S | d	7 } q)
aB   Return the ith prime greater than n.

        i must be an integer.

        Notes
        =====

        Potential primes are located at 6*j +/- 1. This
        property is used during searching.

        >>> from sympy import nextprime
        >>> [(i, nextprime(i)) for i in range(10, 15)]
        [(10, 11), (11, 13), (12, 13), (13, 17), (14, 17)]
        >>> nextprime(2, ith=2) # the 2nd prime after 2
        5

        See Also
        ========

        prevprime : Return the largest prime smaller than n
        primerange : Generate all primes in a given range

    r	   r   r    r   r   )r   r   r#   r   r   r4   r   r#   )r<   r   	nextprimer_   r.   rF   r
   )r   Zithr*   prrG   r   unnr   r   r   rk   (  sR   

rk   c                 C   s   ddl m} t|| } | dk rtd| dk r"dddddd|  S | tjd	 kr>t| \}}||kr:t|d
  S t| S d| d  }| | d
krY|d
 } t| rT| S | d8 } n|d
 } 	 t| rd| S | d8 } t| rn| S | d8 } q^)a   Return the largest prime smaller than n.

        Notes
        =====

        Potential primes are located at 6*j +/- 1. This
        property is used during searching.

        >>> from sympy import prevprime
        >>> [(i, prevprime(i)) for i in range(10, 15)]
        [(10, 7), (11, 7), (12, 11), (13, 11), (14, 13)]

        See Also
        ========

        nextprime : Return the ith prime greater than n
        primerange : Generates all primes in a given range
    r   rB   r   zno preceding primes   r   r   )r   r#   r   r   r    r$   r	   r   r#   )rD   rC   r   rK   r_   r.   rF   r
   )r   rC   r   rm   rn   r   r   r   	prevprimel  s4   
rp   c                 c   s    ddl m} |du rd| } }| |krdS |tjd kr(t| |E dH  dS t|| d } t||}	 t| } | |k rC| V  ndS q7)a
   Generate a list of all prime numbers in the range [2, a),
        or [a, b).

        If the range exists in the default sieve, the values will
        be returned from there; otherwise values will be returned
        but will not modify the sieve.

        Examples
        ========

        >>> from sympy import primerange, prime

        All primes less than 19:

        >>> list(primerange(19))
        [2, 3, 5, 7, 11, 13, 17]

        All primes greater than or equal to 7 and less than 19:

        >>> list(primerange(7, 19))
        [7, 11, 13, 17]

        All primes through the 10th prime

        >>> list(primerange(prime(10) + 1))
        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

        The Sieve method, primerange, is generally faster but it will
        occupy more memory as the sieve stores values. The default
        instance of Sieve, named sieve, can be used:

        >>> from sympy import sieve
        >>> list(sieve.primerange(1, 30))
        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

        Notes
        =====

        Some famous conjectures about the occurrence of primes in a given
        range are [1]:

        - Twin primes: though often not, the following will give 2 primes
                    an infinite number of times:
                        primerange(6*n - 1, 6*n + 2)
        - Legendre's: the following always yields at least one prime
                        primerange(n**2, (n+1)**2+1)
        - Bertrand's (proven): there is always a prime in the range
                        primerange(n, 2*n)
        - Brocard's: there are at least four primes in the range
                        primerange(prime(n)**2, prime(n+1)**2)

        The average gap between primes is log(n) [2]; the gap between
        primes can be arbitrarily large since sequences of composite
        numbers are arbitrarily large, e.g. the numbers in the sequence
        n! + 2, n! + 3 ... n! + n are all composite.

        See Also
        ========

        prime : Return the nth prime
        nextprime : Return the ith prime greater than n
        prevprime : Return the largest prime smaller than n
        randprime : Returns a random prime in a given range
        primorial : Returns the product of primes based on condition
        Sieve.primerange : return range from already computed primes
                           or extend the sieve to contain the requested
                           range.

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Prime_number
        .. [2] http://primes.utm.edu/notes/gaps.html
    r   rB   Nr   r$   r	   )rD   rC   r_   r.   r>   r   rk   )r   r   rC   r   r   r   r>     s"   K
r>   c                 C   sZ   | |krdS t t| |f\} }t| d |}t|}||kr#t|}|| k r+td|S )a$   Return a random prime number in the range [a, b).

        Bertrand's postulate assures that
        randprime(a, 2*a) will always succeed for a > 1.

        Examples
        ========

        >>> from sympy import randprime, isprime
        >>> randprime(1, 30) #doctest: +SKIP
        13
        >>> isprime(randprime(1, 30))
        True

        See Also
        ========

        primerange : Generate all primes in a given range

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Bertrand's_postulate

    Nr	   z&no primes exist in the specified range)mapr<   randomZrandintrk   rp   rK   )r   r   r   r?   r   r   r   	randprime  s   rs   Tc                 C   sr   |rt | } nt| } | dk rtdd}|r)td| d D ]}|t|9 }q|S td| d D ]}||9 }q0|S )a:  
    Returns the product of the first n primes (default) or
    the primes less than or equal to n (when ``nth=False``).

    Examples
    ========

    >>> from sympy.ntheory.generate import primorial, primerange
    >>> from sympy import factorint, Mul, primefactors, sqrt
    >>> primorial(4) # the first 4 primes are 2, 3, 5, 7
    210
    >>> primorial(4, nth=False) # primes <= 4 are 2 and 3
    6
    >>> primorial(1)
    2
    >>> primorial(1, nth=False)
    1
    >>> primorial(sqrt(101), nth=False)
    210

    One can argue that the primes are infinite since if you take
    a set of primes and multiply them together (e.g. the primorial) and
    then add or subtract 1, the result cannot be divided by any of the
    original factors, hence either 1 or more new primes must divide this
    product of primes.

    In this case, the number itself is a new prime:

    >>> factorint(primorial(4) + 1)
    {211: 1}

    In this case two new primes are the factors:

    >>> factorint(primorial(4) - 1)
    {11: 1, 19: 1}

    Here, some primes smaller and larger than the primes multiplied together
    are obtained:

    >>> p = list(primerange(10, 20))
    >>> sorted(set(primefactors(Mul(*p) + 1)).difference(set(p)))
    [2, 5, 31, 149]

    See Also
    ========

    primerange : Generate all primes in a given range

    r	   zprimorial argument must be >= 1r   )r   r<   rK   r   r3   r>   )r   rc   r?   r*   r   r   r   	primorial(  s   2

rt   Fc           
      c   s   t |pd}d }}|| |}}d}||krE|r||k rE|d7 }||kr.|}|d9 }d}|r3|V  | |}|d7 }||krE|r||k s|rV||krV|rOdS |dfV  dS |sd}	| }}t|D ]}| |}qb||kr}| |}| |}|	d7 }	||ksm|	r|	d8 }	||	fV  dS dS )a  For a given iterated sequence, return a generator that gives
    the length of the iterated cycle (lambda) and the length of terms
    before the cycle begins (mu); if ``values`` is True then the
    terms of the sequence will be returned instead. The sequence is
    started with value ``x0``.

    Note: more than the first lambda + mu terms may be returned and this
    is the cost of cycle detection with Brent's method; there are, however,
    generally less terms calculated than would have been calculated if the
    proper ending point were determined, e.g. by using Floyd's method.

    >>> from sympy.ntheory.generate import cycle_length

    This will yield successive values of i <-- func(i):

        >>> def iter(func, i):
        ...     while 1:
        ...         ii = func(i)
        ...         yield ii
        ...         i = ii
        ...

    A function is defined:

        >>> func = lambda i: (i**2 + 1) % 51

    and given a seed of 4 and the mu and lambda terms calculated:

        >>> next(cycle_length(func, 4))
        (6, 2)

    We can see what is meant by looking at the output:

        >>> n = cycle_length(func, 4, values=True)
        >>> list(ni for ni in n)
        [17, 35, 2, 5, 26, 14, 44, 50, 2, 5, 26, 14]

    There are 6 repeating values after the first 2.

    If a sequence is suspected of being longer than you might wish, ``nmax``
    can be used to exit early (and mu will be returned as None):

        >>> next(cycle_length(func, 4, nmax = 4))
        (4, None)
        >>> [ni for ni in cycle_length(func, 4, nmax = 4, values=True)]
        [17, 35, 2, 5]

    Code modified from:
        https://en.wikipedia.org/wiki/Cycle_detection.
    r   r	   r   N)r<   r   )
fZx0ZnmaxvaluesZpowerZlamZtortoiseZharer*   Zmur   r   r   cycle_lengthj  sF   4


rw   c           	      C   sp  t | }|dk rtdg d}|dkr||d  S dtjd }}||t| d krW||d k rM|| d? }|t| d |krE|}n|}||d k s2t|rU|d8 }|S ddlm} dd	lm	} d}t
||||||  }||k r|| d? }||| d |kr|}n|d }||k sw|t| d }||krt|s|d8 }|d8 }||kst|r|d8 }|S )
a   Return the nth composite number, with the composite numbers indexed as
        composite(1) = 4, composite(2) = 6, etc....

        Examples
        ========

        >>> from sympy import composite
        >>> composite(36)
        52
        >>> composite(1)
        4
        >>> composite(17737)
        20000

        See Also
        ========

        sympy.ntheory.primetest.isprime : Test if n is prime
        primerange : Generate all primes in a given range
        primepi : Return the number of primes less than or equal to n
        prime : Return the nth prime
        compositepi : Return the number of positive composite numbers less than or equal to n
    r	   z1nth must be a positive integer; composite(1) == 4)
r#   r   ro   	   
                  ry   r#   r$   r   r[   r]   )r   rK   r_   r.   rb   r
   r`   r\   ra   r^   r<   )	rc   r   Zcomposite_arrr   r   rd   r\   r^   Zn_compositesr   r   r   	composite  sH   r   c                 C   s$   t | } | dk r
dS | t|  d S )ak   Return the number of positive composite numbers less than or equal to n.
        The first positive composite is 4, i.e. compositepi(4) = 1.

        Examples
        ========

        >>> from sympy import compositepi
        >>> compositepi(25)
        15
        >>> compositepi(1000)
        831

        See Also
        ========

        sympy.ntheory.primetest.isprime : Test if n is prime
        primerange : Generate all primes in a given range
        prime : Return the nth prime
        primepi : Return the number of primes less than or equal to n
        composite : Return the nth composite number
    r#   r   r	   )r<   rb   r   r   r   r   compositepi  s   r   )r	   r%   )T)NF)rZ   rr   r   	itertoolsr   r   r   Zsympyr   r   Zsympy.core.compatibilityr   Z	primetestr
   r   r   r   r   r_   r3   rb   rk   rp   r>   rs   rt   rw   r   r   r   r   r   r   <module>   s2      AK
}D
3c
&
BYB