def test_nth_prime():
    """Test nth prime function."""
    assert primesieve.nth_prime(25) == 97
    assert primesieve.nth_prime(26) == 101
    assert primesieve.nth_prime(1, 100) == 101
    assert primesieve.nth_prime(100, 1000000) == 1001311
    assert primesieve.nth_prime(10**8) == 2038074743
Exemplo n.º 2
0
 def generate_hash(self):
     c = nth_prime(1000000)
     a_idx = np.random.randint(10000, 1000000)
     a = nth_prime(a_idx)
     b_idx = np.random.randint(10000, 1000000)
     b = nth_prime(b_idx)
     return lambda x: (a * x + b) % c % self.input_size
    def test_nth_prime(self):
        for testcase1 in ((25, 97), (26, 101), (10**8, 2038074743)):
            self.assertEqual(primesieve.nth_prime(testcase1[0]), testcase1[1])

        for testcase2 in (((1, 100), 101), ((100, 1000000), 1001311)):
            self.assertEqual(
                primesieve.nth_prime(testcase2[0][0], testcase2[0][1]),
                testcase2[1])
Exemplo n.º 4
0
 def __init__(self, m, d, n=12):
     self.m = m
     self.d = d
     self.R = [
         MultiCongGenerator(nth_prime(randint(1000, 10000000)), 63018038201,
                            nth_prime(randint(10000, 100000)))
         for _ in range(n)
     ]
     self.n = n
Exemplo n.º 5
0
    def __init__(self, input_size, num_perm=128, num_minhash=1):
        self.input_size = input_size
        self.num_perm = num_perm
        self.num_minhash = num_minhash

        self.A1s, self.A2s, self.A3s = [], [], []

        for _ in range(self.num_minhash):
            self.A1s.append(
                torch.randint(0, nth_prime(1000000),
                              torch.Size((1, self.num_perm))))
            self.A2s.append(
                torch.randint(0, nth_prime(1000000),
                              torch.Size((1, self.num_perm))))
            self.A3s.append(
                torch.randint(0, nth_prime(1000000),
                              torch.Size((1, self.num_perm))))

        self.A4s = torch.randint(1, nth_prime(1000000),
                                 torch.Size((1, self.num_minhash)))
Exemplo n.º 6
0
    def __init__(self, m):
        self.m = m

        # Pick a random integer between m and 2m
        i = random.randint(m, 2 * m)
        # Get the nth prime greater than i
        self.p = primesieve.nth_prime(1, i)

        # Set a = random int (less than p) (where a != 0)
        self.a = random.randint(1, self.p - 1)

        # Set b = random int (less than p)
        self.b = random.randint(0, self.p - 1)
    def __init__(self, input_size, num_perm=128, num_minhash=1):
        self.input_size = input_size
        self.num_perm = num_perm
        self.num_minhash = num_minhash

        self.A1s, self.A2s, self.A3s, self.Bases = [], [], [], []
        self.BIGPRIME = nth_prime(1000000)
        for _ in range(self.num_minhash):
            self.A1s.append(
                torch.randint(1, self.BIGPRIME, torch.Size(
                    (1, self.num_perm))))
            self.A2s.append(
                torch.randint(1, self.BIGPRIME, torch.Size(
                    (1, self.num_perm))))
            self.A3s.append(
                torch.randint(1, self.BIGPRIME, torch.Size(
                    (1, self.num_perm))))
            self.Bases.append(
                torch.randint(0, self.BIGPRIME, torch.Size(
                    (1, self.num_perm))))

        self.A4s = torch.randint(1, self.BIGPRIME,
                                 torch.Size((1, self.num_minhash)))
        self.B4 = np.random.randint(0, self.BIGPRIME)
Exemplo n.º 8
0
def next_prime(p):
    print(primesieve.nth_prime(p))
Exemplo n.º 9
0
def test_nth_prime():
    assert primesieve.nth_prime(25) == 97
    assert primesieve.nth_prime(26) == 101
Exemplo n.º 10
0
    for i in range(z):
        x = 1 + (i * z)
        if x % e == 0:
            d = int(x / e)
            break
    print('d =', d)
    return [e, n], [d, n]


def encrypt(message, public_key):
    encrypt_message = []
    for m in message:
        encrypt_message.append(pow(ord(m), public_key[0]) % public_key[1])
    return encrypt_message


def decrypt(message, private_key):
    decrypt_message = ''
    for m in message:
        decrypt_message += chr(pow(m, private_key[0]) % private_key[1])
    return decrypt_message


p = primesieve.nth_prime(random.randint(50, 150))  #457
q = primesieve.nth_prime(random.randint(50, 150))  #1213
public_key, private_key = RSA(p, q)
print('public_key', public_key)
print('private_key', private_key)
msg = encrypt('Hello, world!', public_key)
print('Message:', decrypt(msg, private_key))
Exemplo n.º 11
0
from math import log
from faktorisering import primesbelow
from primesieve import nth_prime


def ith_fast(n):
    stop = int(n *
               (log(n) + log(log(n) - 1 + 1.8 * log(log(n)) / float(log(n)))))
    sieve = primesbelow(stop)
    return sieve[n - len(sieve) - 1]


if __name__ == "__main__":
    import timeit
    limit = 10001
    print ith_fast(limit)
    print nth_prime(limit)
    times = 50
    t1 = timeit.timeit("ith_fast(1000001)",
                       setup="from __main__ import ith_fast",
                       number=times) / float(times)
    t2 = timeit.timeit("nth_prime(1000001)",
                       setup="from __main__ import nth_prime",
                       number=times) / float(times)

    print "My solution used: ", 1000 * t1, "ms"
    print "The C++ solution used:  ", 1000 * t2, "ms"

    print "The C++ solution was:   ", t1 / float(t2), "times faster than mine."
Exemplo n.º 12
0
def main():
    ''' Driver function '''
    print(nth_prime(10001))
Exemplo n.º 13
0
import primesieve
import random


class User:
    def __init__(self, secret_num, p, g):
        self.p = p
        self.g = g
        self.secret_num = secret_num
        self.key = pow(g, secret_num) % p

    def get_key(self):
        return self.key

    def get_secret_key(self, companion_key):
        return pow(companion_key, self.secret_num) % self.p


g = primesieve.nth_prime(random.randint(50, 150))  #257
p = primesieve.nth_prime(random.randint(50, 150))  #23
Naruto = User(random.randint(1, 500), p, g)
Sasuke = User(random.randint(1, 500), p, g)
print('Natuto key:', Naruto.get_secret_key(Sasuke.get_key()))
print('Sasuke key:', Sasuke.get_secret_key(Naruto.get_key()))
Exemplo n.º 14
0
    else:
        print('\nМ_client != М_server')
        return -1

    R_server = hash_generation(A, М_client, K_server)
    R_client = hash_generation(A, М_client, K_client)
    if R_server == R_client:
        print('R_server == R_client')
        print(R_server, R_client)
        return 1
    else:
        print('R_server != R_client')
        return -1


N = primesieve.nth_prime(random.randint(10, 100))
while True:
    if prime_check((N - 1) // 2):
        break
    N = primesieve.nth_prime(random.randint(10, 100))
print('N =', N)

g = generator(N)
print('g =', g)

k = hash_generation(N, g)
print('k =', k)

I = 'Username'
p = '123456789'
s = rand_generation(64)
Exemplo n.º 15
0
def test_nth_prime():
    assert primesieve.nth_prime(25) == 97
    assert primesieve.nth_prime(26) == 101
    assert primesieve.nth_prime(1, 100) == 101
    assert primesieve.nth_prime(100, 1000000) == 1001311
    assert primesieve.nth_prime(10**8) == 2038074743
def test_nth_prime():
    assert primesieve.nth_prime(25) == 97
    assert primesieve.nth_prime(26) == 101
    assert primesieve.nth_prime(1, 100) == 101
    assert primesieve.nth_prime(100, 1000000) == 1001311
Exemplo n.º 17
0
 def __init__(self, a, b):
     self.a = a
     self.b = b
     self.R = MultiCongGenerator(nth_prime(randint(1000, 10000000)),
                                 63018038201,
                                 nth_prime(randint(10000, 100000)))
Exemplo n.º 18
0
def test_nth_prime():
    assert primesieve.nth_prime(25) == 97
    assert primesieve.nth_prime(26) == 101
Exemplo n.º 19
0
def list_primes(n):
    for i in range(n):
        print(primesieve.nth_prime(i))
Exemplo n.º 20
0
 def __init__(self, N, p = None):
   self.N = N
   if p is None:
     p = nth_prime(1, 1 << max(32, ceil(log2(N))))  
   assert p >= N, 'Prime number p should be at least N!'
   self.p = p
Exemplo n.º 21
0
 def __init__(self, bins, elements):
     self.bins = bins # range
     self.elements = elements # domain
     self.p = nth_prime(1, elements) # finds the first prime greater than `elements`