def test__Sieve__second_level_compounding_repr():
even_sieve = Sieve(is_even)
positive_sieve = Sieve(is_positive)
thirteen_sieve = Sieve(is_thirteen)
compound_sieve = (even_sieve & positive_sieve) | thirteen_sieve
assert repr(
compound_sieve) == "Sieve((is_even & is_positive) | is_thirteen)"
def main():
sum = 0
s = Sieve()
for i in range(1, 10000):
if s.is_amicable(i):
sum += i
print(sum)
def __init__(self, params, logfile):
"""
Optional parameters:
* parse_output (bool, True): Whether the sieve should write its own output file.
Optional parameters passed to SGA:
* max_edges (int, 400)
* numcpu (int, 4)
* min_branch_length (int, 35)
* min_merge_overlap (int, 15)
* min_assembly_overlap (int, 5)
* max_gap_divergence (int, 0)
* resolve_small (int, 500)
* error_rate (float, 0.02)
"""
param_names = [('parse_output', True), ('max_edges', 400),
('numcpu', 4), ('min_branch_length', 35),
('min_merge_overlap', 15), ('min_assembly_overlap', 5),
('max_gap_divergence', 0), ('resolve_small', 500),
('error_rate', 0.02)]
Sieve.__init__(self,
params,
logfile,
name='SGA',
param_names=param_names)
def test__Sieve__intersection():
even_sieve = Sieve(is_even)
positive_sieve = Sieve(is_positive)
intersection_sieve = even_sieve & positive_sieve
assert intersection_sieve(8) is True
assert intersection_sieve(-8) is False
assert intersection_sieve(9) is False
assert intersection_sieve(-9) is False
def test__Sieve__second_level_compounding():
even_sieve = Sieve(is_even)
positive_sieve = Sieve(is_positive)
thirteen_sieve = Sieve(is_thirteen)
compound_sieve = (even_sieve & positive_sieve) | thirteen_sieve
assert compound_sieve(8) is True
assert compound_sieve(-8) is False
assert compound_sieve(13) is True
def __init__(self, n_holders, min_holder, secret, verbose=False):
self.__verbose = verbose
self.__sieve = Sieve()
self.__n_holder = n_holders
self.__min_holder = min_holder
self.__holders = [Holder() for _ in range(n_holders)]
self.__secret = secret
self.__generateHolders()
def main():
sv = Sieve()
count = 0
for p in sv.prime_range(2, 1000000):
if all(sv.is_prime(i) for i in number_rotations(p)):
count += 1
print(count)
def main():
s = Sieve()
sum = 0
prime = 2
while prime < 2000000:
sum += prime
prime = s.next_prime(prime)
print(sum)
def main():
s = Sieve()
prime = 2
count = 1
while count < 10001:
prime = s.next_prime(prime)
count += 1
print(prime)
def __init__(self, params, logfile):
"""
Optional parameters:
* item_limit (int, default 0): Maximum number of sequences to parse. 0 means no limit.
"""
Sieve.__init__(self,
params,
logfile,
name='FASTA translator',
param_names=[('item_limit', 0)])
def __init__(self,
bg,
sieve_function=None,
general=None,
reach_function=None,
selfcentered=False):
self.bg = bg
self.general = general
self.sieve = Sieve(general, sieve_function) if sieve_function else None
self.reach = Sieve(general, reach_function) if reach_function else None
self.selfcentered = selfcentered
def main():
p = Sieve()
values = set()
for a in range(2, 101):
base = p.factorize(a)
for b in range(2, 101):
elt = frozenset(power(base, b))
values.add(elt)
print(len(values))
def main():
s = Sieve()
largest = 0
largets_value = 0
for p in s.prime_range(7, 1000):
size = tenlog(p)
if size > largest:
largest = size
largest_value = p
print(largest_value)
def main():
s = Sieve()
maxv = 0
max_product = 0
for a in range(-999, 1000):
for b in range(-999, 1000):
count = s.prime_count(a, b)
if count > maxv:
maxv = count
max_product = a * b
print(max_product)
class Area(object):
def __init__(self,
bg,
sieve_function=None,
general=None,
reach_function=None,
selfcentered=False):
self.bg = bg
self.general = general
self.sieve = Sieve(general, sieve_function) if sieve_function else None
self.reach = Sieve(general, reach_function) if reach_function else None
self.selfcentered = selfcentered
def clone(self, general):
sieve = self.sieve.function if self.sieve else None
reach = self.reach.function if self.reach else None
return self.__class__(self.bg, sieve, general, reach,
self.selfcentered)
def get_all_tiles(self, x, y):
return self.get_tiles()
def get_tiles(self, x=-1, y=-1):
if self.selfcentered:
(x, y) = (self.general.x, self.general.y)
if self.reach and self.bg.is_inside(
x, y) and not self.reach.apply(self.bg.tiles[(x, y)]):
return []
if not self.sieve:
return self.get_all_tiles(x, y)
return filter(self.sieve.apply, self.get_all_tiles(x, y))
def main(): sieve = Sieve(1000000) s = [p for p in sieve] max_len = 0 max_sum = 0 for i in xrange(len(s) - 1): for j in xrange(i + 1, len(s)): cons_sum = sum(s[k] for k in xrange(i, j + 1)) if cons_sum > 1000000: break cons_len = j - i + 1 if sieve.isPrime(cons_sum): if cons_len > max_len: max_len = cons_len max_sum = cons_sum print max_sum print max_len
def __init__(self, params, logfile):
"""
Mandatory parameters:
* sieve (module): Sieve to run
* params (dict): Parameter set listing the different values for each parameter on the following form::
{
'param1': [1, 2],
'param2': ['A', 'B', 'C']
}
The supplied sieve will run once for each possible combination of parameters. The preceding example will thus run 2*3=6 times.
"""
param_names = ['sieve', 'params']
Sieve.__init__(self,
params,
logfile,
name='MultiRunner',
param_names=param_names)
def __init__(self, params, logfile):
"""
Mandatory parameters:
* model_path (str): Path to .hmm model file to use for hmmsearch.
Optional parameters:
* hmmsearch_out(str, 'hmmsearch_out'): Path to temporary hmmsearch output file.
* numcpu (int, 4): Number of threads to use for hmmsearch
* write_only_domain (bool, True): If output FASTA file should contain entire input sequence or just matching domain.
* use_heuristics (bool, True): Heuristics on/off; there is little reason not to use heuristics, HMMer has a higher propensity for crashing if not used and it only increases the number of really low scoring hits anyway,
* longseqdef (int, 151): Sequences longer than this will be considered "long" and are thus compared to `longseqcutoff` instead of `classificationfunction`.
* longseqcutoff (float, 109.64): The classification cutoff (minimum domain score) for long sequences. That is, "long" sequences will only pass if they have a score higher than this.
* minscore (int, 0): Minimum domain score, regardless of length, to pass a sequence.
* min_sequence_length (int, 20): Only consider sequences longer than this.
* max_domain_length (int, 21844): Do not include sequences where the maximum domain is longer than this.
* max_sequence_length (int, 21844000): Do not include sequences longer than this.
* classificationfunction (function, lambda L: self.classifyK*L + self.classifyM): Classification function. The domain score of sequences shorter than `longseqdef` are compared to the result of this function, with the sequence length fed as the parameter. Only those with a domain score higher will pass.
* classifyK (float, 0.7778): Parameter to the default `classificationfunction`.
* classifyM (float, -7.89): Parameter to the default `classificationfunction`.
"""
param_names = [
'model_path',
('hmmsearch_out', 'hmmsearch_out'),
('numcpu', 4),
('write_only_domain', True),
('use_heuristics', True),
('longseqdef', 151),
('longseqcutoff', 109.64),
('minscore', 0),
('min_sequence_length', 20), #minimum fragment length allowed.
('max_domain_length', 21844),
('max_sequence_length', 21844000),
('classifyK', 0.7778),
('classifyM', -7.89),
('classificationfunction', lambda L: self.classifyK*L + self.classifyM)
]
Sieve.__init__(self, params, logfile, name='HMMer hmmsearch', param_names=param_names)
def test_sieve():
s = Sieve(100)
n.assert_equal(s.isPrime(0), False)
n.assert_equal(s.isPrime(1), False)
n.assert_equal(s.isPrime(2), True)
n.assert_equal(s.isPrime(4), False)
n.assert_equal(s.isPrime(9), False)
n.assert_equal(s.isPrime(2), True)
n.assert_equal(s.isPrime(7), True)
n.assert_equal(s.isPrime(97), True)
n.assert_equal(s.isPrime(99), False)
def main():
sieve = Sieve()
number_of_holders = int(input("Input number of holders : "))
while number_of_holders < 1:
number_of_holders = int(
input("Number must be larger than one. Try again : "))
min_number_to_solve = int(
input("Input minimum number of holders to retrieve the secret : "))
while min_number_to_solve > number_of_holders or min_number_to_solve < 1:
min_number_to_solve = int(
input(
"Number of minimum must be between 1 and number of holders. Try again : "
))
secret = int(input("Input secret : "))
while secret < 0:
secret = int(input("Secret must not be less than zero. Try again :"))
# SSS Object
generation_start = time.time()
SSS = AsmuthBloom(number_of_holders,
min_number_to_solve,
secret,
verbose=True)
generation_end = time.time()
# Sequence
print("Sequence")
for sequence in SSS.getSequence():
print(sequence)
# Print holders
for holder in SSS.getHolders():
print(holder)
# Solve secret
# For now choice is totally random
solve_start = time.time()
secret = SSS.solve()
solve_end = time.time()
print("Generation time (s): " + str(generation_end - generation_start))
print("Solving time (s): " + str(solve_end - solve_start))
print(secret)
class Area(object):
def __init__(self, bg, sieve_function=None, general=None, reach_function=None, selfcentered=False):
self.bg = bg
self.general = general
self.sieve = Sieve(general, sieve_function) if sieve_function else None
self.reach = Sieve(general, reach_function) if reach_function else None
self.selfcentered = selfcentered
def clone(self, general):
sieve = self.sieve.function if self.sieve else None
reach = self.reach.function if self.reach else None
return self.__class__(self.bg, sieve, general, reach, self.selfcentered)
def get_all_tiles(self, x, y):
return self.get_tiles()
def get_tiles(self, x=-1, y=-1):
if self.selfcentered:
(x, y) = (self.general.x, self.general.y)
if self.reach and self.bg.is_inside(x, y) and not self.reach.apply(self.bg.tiles[(x, y)]):
return []
if not self.sieve:
return self.get_all_tiles(x, y)
return filter(self.sieve.apply, self.get_all_tiles(x, y))
from sieve import Sieve
# n*n + a*n + b
# where n < 80, a < 1000 and b < 1000. so max of that expression is
# 80*80 + 1000*80 + 1000 = 87400
primes = Sieve(87400)
max_a = 0
max_b = 0
# currently we know n = 40 when a = 1 and b = 41
max_n = 40
# iterate over all possibilities for a
for a in range(-999, 999):
# iterate over all possibilities for b
for b in range(-999, 999):
# look for a series of consecutive primes starting with n = 0
n = 0
while (primes.is_prime(abs(n*n + a*n + b))):
n += 1
# did we find a bigger series than the current one?
if (n > max_n):
max_a = a;
max_b = b;
max_n = n;
print("a: %d, b: %d, n: %d, product: %d" %(max_a, max_b, max_n, (max_a*max_b)))
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 30 10:55:07 2018
@author: XZentus
"""
from math import log10
from sieve import Sieve
limit = 10000
sieve = Sieve(100000000)
def concat_nums(n1, n2):
return n1 * 10**(1 + int(log10(n2))) + n2
def check_pair(n1, n2, sieve=sieve):
is_prime = sieve.is_prime
return is_prime(concat_nums(n1, n2)) and is_prime(concat_nums(n2, n1))
def check_collect(lst, elements_to_add):
next_prime = sieve.next_prime
is_prime = sieve.is_prime
if elements_to_add == 0:
def test__Sieve__union_repr():
even_sieve = Sieve(is_even)
positive_sieve = Sieve(is_positive)
intersection_sieve = even_sieve | positive_sieve
assert repr(intersection_sieve) == "Sieve(is_even | is_positive)"
from sieve import Sieve
from itertools import combinations
sieve = Sieve(10000)
def permutations(s):
if s == '':
yield ''
for i, c in enumerate(s):
for perm in permutations(''.join(d for j, d in enumerate(s) if j != i)):
yield c + perm
for p in sieve:
if len(str(p)) != 4:
continue
p_perm = sorted({x for x in map(int, permutations(str(p))) if sieve.isPrime(x)})
if len(p_perm) < 3:
continue
for combi in combinations(p_perm, 3):
if (combi[1] - combi[0]) == (combi[2] - combi[1]):
print combi
break
def test__Sieve__negation_repr():
sieve = Sieve(is_even)
is_odd = -sieve
assert repr(is_odd) == "Sieve(not(is_even))"
def test__Sieve__call():
sieve = Sieve(is_even)
assert sieve(8) is True
assert sieve(9) is False
def test__Sieve__repr():
sieve = Sieve(is_even)
assert repr(sieve) == "Sieve(is_even)"
def test__Sieve__creation():
sieve = Sieve(is_even)
result += 2
found = True
# result = 3, primes = [2], j = 0, primes[0]*primes[0] > 3 ==> prime
# result = 5, primes = [2, 3], j = 0, result%primes[0] == 1
# j = 1, primes[1]*primes[1] > 5 ==> prime
# result = 7, primes = [2, 3, 5], j = 0, result%primes[0] == 1
# j = 1, primes[1]*primes[1] > 7 ==> prime
# result = 9, primes = [2, 3, 5, 7], j = 0, result%primes[0] == 1
# j = 1, result%primes[1] == 0 ==> not prime
j = 0
while (found and j < len(primes) and primes[j]*primes[j] <= result):
if (result % primes[j] == 0):
found = False
j += 1
if (found):
primes.append(result)
return result
targets = [ 6, 11, 101, 1001, 10001, 50001 ]
sizes = [ 20, 40, 600, 8000, 105000, 612000 ]
# for target in targets:
# print("Worst(%d): %d" %(target, worst_index(target)))
for i, target in enumerate(targets):
sieve = Sieve(sizes[i])
print("Sieve(%d): %d" %(target, sieve.index(target)))
for target in targets:
print("Modified Sieve(%d): %d" %(target, sieve2_index(target)))
for target in targets:
print("Improved Sieve(%d): %d" %(target, sieve3_index(target)))
def __init__(self, bg, sieve_function=None, general=None, reach_function=None, selfcentered=False): self.bg = bg self.general = general self.sieve = Sieve(general, sieve_function) if sieve_function else None self.reach = Sieve(general, reach_function) if reach_function else None self.selfcentered = selfcentered
class AsmuthBloom:
def __init__(self, n_holders, min_holder, secret, verbose=False):
self.__verbose = verbose
self.__sieve = Sieve()
self.__n_holder = n_holders
self.__min_holder = min_holder
self.__holders = [Holder() for _ in range(n_holders)]
self.__secret = secret
self.__generateHolders()
def __generateHolders(self):
self.__generateSequence()
self.__generateRandom()
for i in range(self.__n_holder):
self.__holders[i].modulo = self.__sequence[i + 1]
self.__holders[i].secret = self.__y % self.__holders[i].modulo
def __generateSequence(self):
initial_multiplier = int(self.__secret / 10)
# Get first prime in sequence
first_prime = self.__sieve.getFirstPrimeLargerThan(self.__secret)
sequenceValid = False
# Get the rest of sequence
while not sequenceValid:
current_sequence = [first_prime]
temp_prime = self.__sieve.getFirstPrimeLargerThan(
self.__secret * initial_multiplier)
for _ in range(self.__n_holder):
temp_prime = self.__sieve.getFirstPrimeLargerThan(temp_prime)
current_sequence.append(temp_prime)
if self.__isSequenceValid(current_sequence):
sequenceValid = True
else:
initial_multiplier = initial_multiplier + 1
self.__sequence = current_sequence
self.__M = self.__seqprod(self.__sequence[1:self.__min_holder + 1])
if self.__verbose:
print("Sequence : " + str(self.__sequence))
print("Big-M : " + str(self.__M))
# Generate a random number
def __generateRandom(self):
max = int((self.__M - self.__secret) / self.__sequence[0])
self.__random_number = random.randint(1, max)
self.__y = self.__secret + self.__random_number * self.__sequence[0]
if self.__verbose:
print("Random number : " + str(self.__random_number))
print("Y-value : " + str(self.__y))
### UTILS
def __isSequenceValid(self, seq):
lower_product = self.__seqprod(seq[1:self.__min_holder + 1])
upper_product = seq[0] * self.__seqprod(
seq[self.__n_holder - self.__min_holder + 2:])
return lower_product > upper_product
def getSequence(self):
return self.__sequence
def __seqprod(self, iterable):
product = 1
for item in iterable:
product = product * item
return product
def getHolders(self):
return self.__holders
### Solver
def solve(self):
chosen_holders = random.sample(self.__holders, self.__min_holder)
if self.__verbose:
print("Chosen holders :")
for holder in chosen_holders:
print(holder)
## Solver CRT
modulo_list = [holder.modulo for holder in chosen_holders]
remainder_list = [holder.secret for holder in chosen_holders]
solution = chinese_remainder(modulo_list, remainder_list)
if self.__verbose:
print("CRT Solution : " + str(solution))
return (solution) % self.__sequence[0]
# Find inverse
# Assume coprime
# Using native methods. We can fix them later
def __inverse(self, multiplier, modulo):
for i in range(modulo):
if ((multiplier * i) % modulo) == 1:
return i
def test__Sieve__negation():
sieve = Sieve(is_even)
is_odd = -sieve
assert is_odd(8) is False
assert is_odd(9) is True
def test__Sieve__empty():
sieve = Sieve()
assert repr(sieve) == "Sieve(True)"
assert sieve(10) is True
assert sieve("mille") is True
assert sieve({}) is True
ovpn_path = results.ovpn_path
config_path = results.config_path
outfile = results.outfile
date = results.date
timeout = results.timeout
try:
is_admin = os.getuid() == 0
except AttributeError:
is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
if not is_admin:
raise Exception('Please run as root/admin, since OpenVPN needs admin privileges')
if os.path.isfile('output/' + outfile): # Check if file is existent, if not, remove dates and proceed
combos = 'output/' + outfile
else:
sv = Sieve(date=date, outfile=outfile)
sv.filter()
combos = sv.write()
if config_path is None:
for filename in os.listdir('ovpn/'):
if filename.endswith('.ovpn'):
config_path = 'ovpn/' + filename
break
cn = Connector(ovpn_path=ovpn_path, config_path=config_path, combos=combos,
timeout=timeout)
cn.unpack()
cn.connect()
def solve(n):
l = [0] * n
for i in range(1, n + 1):
if not l[i - 1]:
coprimes = []
for j in range(2, i):
if gcd(i, j) == 1:
coprimes.append(j)
l[i - 1] = 1 + len(coprimes)
for c in coprimes:
if i * c > n:
break
l[(i * c) - 1] = l[i - 1] * l[c - 1]
return l
s = Sieve(10 ** 7)
ps = s.list()
def phi(n):
if n < 2:
return 1
if s.is_prime(n):
return n - 1
if (n & 1) == 0:
m = n >> 1
return phi(m) if m & 1 else phi(m) << 1
for p in ps:
if p > n:
# The Sieve of Eratosthenes algorithm developed in Euler #7 was used here to
# yield marvelous result:
# Target Sum Pre-Sieve Post-Sieve
# 10 17 0 0
# 100000 454396537 12 .05
# 500000 9914236195 274 .24
# 1000000 37550402023 1007 .47
# 1500000 82074443256 2201 .72
# 2000000 142913828922 3850 .97
#
from sieve import Sieve
targets = [10, 100000, 500000, 1000000, 1500000, 2000000]
for target in targets:
primes = Sieve(target)
print("Sum primes(%d): %d" %(target, primes.sum()))
