Add files via upload

Author: git4robot

dist/find_primes-1.0.0-py3-none-any.whl

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: find-primes
+Version: 1.2.1
+Summary: A module for finding primes.
+Home-page: UNKNOWN
+Author: JamesJ
+Author-email: GGJamesQQ@yeah.net
+License: UNKNOWN
+Description: Find Primes is a library to find all kinds of primes.
+        
+        **Install**
+        ```shell
+        pip install find-primes
+        ```
+        **[Twin Primes](https://en.wikipedia.org/wiki/Twin_prime)**
+        
+        A twin prime is a prime number that is either 2 less or 2 more than another prime number.
+        
+        Example: Find all twin primes below 1000.
+        ```python
+        from find_primes import find_twins
+        print(find_twins(1000))
+        ```
+        
+        **[Palindrome Primes](https://en.wikipedia.org/wiki/Palindromic_prime)**
+        
+        A palindrome prime is a prime number that is also a palindrome number.
+        
+        Example: Find all palindrome primes below 1000.
+        ```python
+        from find_primes import find_palindromes
+        print(find_palindromes(1000))
+        ```
+        
+        **[Emirps](https://en.wikipedia.org/wiki/Emirp)**
+        
+        An emirp is a prime number that results in a different prime when its decimal digits are reversed.
+        
+        Example: Find all emirps below 1000.
+        ```python
+        from find_primes import find_reverse
+        print(find_reverse(1000))
+        ```
+        
+        **[Primes in Arithmetic Progression](https://en.wikipedia.org/wiki/Primes_in_arithmetic_progression)**
+        
+        Primes in arithmetic progression are any sequence of at least three prime numbers that are consecutive terms in an arithmetic progression.
+        
+        Example: Find all primes in arithmetic progression below 1000.
+        ```python
+        from find_primes import find_arithmetic_prime_progressions
+        print(find_arithmetic_prime_progressions(1000))
+        ```
+        
+        **[Mersenne Primes](https://en.wikipedia.org/wiki/Mersenne_prime)**
+        
+        A mersenne prime is a prime number that is one less than a power of two.
+        
+        Example: Find all mersenne primes below 600000.
+        ```python
+        from find_primes import find_mersenne_primes
+        print(find_mersenne_primes(600000))
+        ```
+        
+        **[Fermat Pseudoprimes](https://en.wikipedia.org/wiki/Fermat_pseudoprime)**
+        
+        A fermat pseudoprime is a pseudoprime that satisfies fermat's little theorem.
+        
+        Example: Find all fermat pseudoprimes below 1000.
+        ```python
+        from find_primes import find_fermat_pseudoprime
+        print(find_fermat_pseudoprime(1000))
+        ```
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

dist/find_primes-1.0.0.post1-py3-none-any.whl

@@ -0,0 +1,7 @@
+README.md
+setup.py
+find_primes/__init__.py
+find_primes.egg-info/PKG-INFO
+find_primes.egg-info/SOURCES.txt
+find_primes.egg-info/dependency_links.txt
+find_primes.egg-info/top_level.txt

dist/find_primes-1.0.0.post1.tar.gz

@@ -0,0 +1 @@
+

dist/find_primes-1.0.0.tar.gz

@@ -0,0 +1 @@
+find_primes

dist/find_primes-1.0.0b1-py3-none-any.whl

@@ -0,0 +1,197 @@
+'''A module to finds all kinds of primes.'''
+from time import time
+from math import log
+
+NUMPY_ENABLED = True
+try:
+    from numpy import ones, nonzero, __version__
+    print(f'Detected numpy version {__version__}')
+except ImportError:
+    NUMPY_ENABLED = False
+
+__version__ = 1.0
+
+def _check_num(n):
+    if not isinstance(n, int):
+        raise TypeError(f'Type of argument n should be int, got {type(n).__name__}')
+
+    if n < 0:
+        raise ValueError(f'The number of argument n should be greater than 0, got {n}')
+
+def is_prime(n):
+    '''
+    If n is prime, return True.
+    '''
+    _check_num(n)
+    if n in [2, 3, 5, 7]:
+        return True
+
+    if not (n % 10 % 2) or n % 10 not in [1, 3, 7, 9] or n == 1 or not isinstance(n, int):
+        return False
+
+    for i in range(2, int(n ** 0.5 + 1)):
+        if n % i == 0:
+            return False
+
+    return True
+
+def all_primes(n, output = 'array'):
+    '''
+    Return a prime list below n.
+
+    Arguments:
+    output ----- 'array' or 'list' ----- The output type of the function.
+    '''
+    _check_num(n)
+    if NUMPY_ENABLED:
+        sieve = ones(n + 1, dtype = bool)
+    else:
+        sieve = [True] * (n + 1)
+
+    for i in range(2, int(n ** 0.5) + 1):
+        if sieve[i]:
+            for j in range(i * i, n + 1, i):
+                sieve[j] = False
+
+    if NUMPY_ENABLED:
+        s = nonzero(sieve)[0]
+        if output == 'list':
+            return s.tolist()[2:]
+
+        return s[2:]
+
+    else:
+        return [x for x in range(2, n + 1) if sieve[x]]
+
+def find_twins(n):
+    '''
+    Return a dict that has all twin primes below n.
+    '''
+    _check_num(n)
+    primes = all_primes(n)
+    twin_primes = {}
+    for ix, xp in enumerate(primes):
+        if ix == len(primes) - 1:
+            break
+
+        if primes[ix + 1] - xp == 2:
+            twin_primes[xp] = primes[ix + 1]
+
+    return twin_primes
+
+def find_palindromes(n):
+    '''
+    Return a list that has all palindromes primes below n.
+    '''
+    _check_num(n)
+    primes = all_primes(n)
+    palin_primes = []
+    for ix, xp in enumerate(primes):
+        palin_num = int(str(xp)[::-1])
+        if is_prime(palin_num) and palin_num == xp and xp > 10:
+            palin_primes.append(palin_num)
+
+    return palin_primes
+
+def find_reverse(n):
+    '''
+    Return a dict that has all reverse primes below n.
+    '''
+    _check_num(n)
+    primes = all_primes(n)
+    reverse_primes = {}
+    for ix, xp in enumerate(primes):
+        reverse_num = int(str(xp)[::-1])
+        if is_prime(reverse_num) and xp > 10:
+            reverse_primes[xp] = reverse_num
+
+    palin_primes = find_palindromes(n)
+    for x in palin_primes:
+        if reverse_primes.get(x):
+            reverse_primes.pop(x)
+
+    return reverse_primes
+
+def find_square_palindromes(n):
+    '''
+    Return a dict that has all square palindrome primes below n.
+    '''
+    _check_num(n)
+    palin_primes = find_palindromes(n)
+    square_palin_prime = {}
+    for x in palin_primes:
+        if str(x ** 2)[::-1] == str(x ** 2):
+            square_palin_prime[x] = x ** 2
+
+    return square_palin_prime
+
+def find_arithmetic_prime_progressions(n):
+    '''
+    Return a list that has all arithmetic prime progression below n.
+    '''
+    _check_num(n)
+    primes = all_primes(n)
+    time = 0
+    arithmetic_prime_list = []
+    for i, xp in enumerate(primes):
+        for j in range(i + 1, len(primes)):
+            a0, a1 = primes[i], primes[j]
+            an = a1 + a1 - a0
+            k = []
+            while an < n and an in primes:
+                k.append(an)
+                an += a1 - a0
+
+            if len([a0, a1] + k) >= 3:
+                if k and not time:
+                    arithmetic_prime_list = [[a0, a1] + k]
+
+                if time:
+                    arithmetic_prime_list += [[a0, a1] + k]
+                time += 1
+
+    return arithmetic_prime_list
+
+def find_mersenne_primes(n):
+    '''
+    Return a list that has all mersenne primes below n.
+    '''
+    _check_num(n)
+    primes = set(all_primes(n))
+    result = []
+    for i in range(2, int(log(n + 1, 2)) + 1):
+        result.append(2 ** i - 1)
+
+    mersenne_primes = primes.intersection(result)
+    return sorted(mersenne_primes)
+
+def find_fermat_pseudoprime(n):
+    '''
+    Return a list that has all fermat pseudoprimes below n.
+    '''
+    _check_num(n)
+    primes = all_primes(n)
+    a = 2
+    fermat_pseudoprimes = []
+    composites = [x for x in range(3, n + 1, a) if x not in primes]
+    for x in composites:
+        if (a ** (x - 1) - 1) % x == 0:
+            fermat_pseudoprimes.append(x)
+
+    return fermat_pseudoprimes
+
+def main():
+    '''A test of this module.'''
+    start_tm = time()
+    print(f'Twin primes: {find_twins(4750)}\n')
+    print(f'Palindome primes: {find_palindromes(20000)}\n')
+    print(f'Reverse primes: {find_reverse(3000)}\n')
+    print(f'Square palindome primes: {find_square_palindromes(500)}\n')
+    print(f'Arithmetic prime progressions: {find_arithmetic_prime_progressions(125)}\n')
+    print(f'Mersenne Primes: {find_mersenne_primes(525000)}\n')
+    print(f'Fermat Pseudoprime: {find_fermat_pseudoprime(1000)}')
+    end_tm = time()
+    print(f'Time: {round(end_tm - start_tm, 12)} seconds.')
+
+if __name__ == '__main__':
+    main()