def test_generate_lots_has_all_primes(self):
non_primes = []
for candidate in list(primes.generate_primes(10000)):
if not _prime(candidate):
non_primes.append(candidate)
assert_equals([], non_primes)
def test_generate_primes(self):
primes_gen = primes.generate_primes()
primes_true = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191]
for pt in primes_true:
self.assertEqual(next(primes_gen), pt)
def generate_primes_to_n(n):
known_primes = primes.load_pickled_primes()
ps = primes.generate_primes(n)
if len(ps) > len(known_primes):
known_primes = ps
f.write("----------------------------------------\n")
f.write("Date: " + time.strftime('%m-%d-%Y @ %H:%M') + "\n")
f.write("Number of primes generated = %d \n" % (len(ps)))
f.write("Highest prime in primes.pickle = %d \n" % (known_primes[-1]))
f.write("Number of primes in primes.pickle = %d \n\n\n" % (len(known_primes)))
f.flush()
primes.pickle_primes(ps)
f.flush()
f.close()
return ps
def Prime_List():
'''
This function will generate a list of prime numbers
'''
max = input_int('Biggest prime number? ')
primes = generate_primes(max)
print()
print('Primes <= {0}: {1}'.format(max, list(primes)))
print()
input('Press Enter')
return
def encode(sentence, hex_output):
sentence = " ".join(sentence.splitlines())
words = sentence.split(" ")
longest_word_length = 0
for word in words:
if len(word) > longest_word_length:
longest_word_length = len(word)
required_primes = primes.generate_primes(longest_word_length)
godel_words = []
for word in words:
godel_word = make_godel_word(word, required_primes)
if hex_output:
godel_word = format(godel_word, 'x')
godel_words.append(str(godel_word))
return "|".join(godel_words)
def initialize_primes(self, max_primes=10000000):
"""Generates an initial list of primes using primes.generate_primes(n)
Args:
f: File to log info about primes, which for now is just the total number
or primes.
Returns: List of primes self.known_primes_
Raises: nothing
"""
self.max_primes_ = max_primes
self.next_prime_ = 0 # set this back to the beginning of the list
self.logger_.plog("Initialize primes to %s \n" % (max_primes))
# our object then builds an array of all the known primes up to max_primes
self.known_primes_ = primes.generate_primes(max_primes)
primes.pickle_primes(self.known_primes_)
self.logger_.plog("Primes found: " + str(len(self.known_primes_)) + "\n")
return self.known_primes_
def encode(sentence, hex_output):
sentence = " ".join(sentence.splitlines())
words = sentence.split(" ")
longest_word_length = 0
for word in words:
if len(word) > longest_word_length:
longest_word_length = len(word)
required_primes = primes.generate_primes(longest_word_length)
godel_words = []
for word in words:
godel_word = make_godel_word(word, required_primes)
if hex_output:
godel_word = format(godel_word, 'x')
godel_words.append(str(godel_word))
return "|".join(godel_words)
#!/usr/bin/python
"""This is only a test. Attempting to graph something with matplotlib.
It looks like plt.plot can graph all the primes filters in one graph
so if this thing ever works I'll do that. The format is (I think)
plt.plot(dates, values, 'attr', dates, values, 'attr', dates, values, 'attr')
"""
import primes
import time
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
datefile = "./plot-data/llt-graph"
f = open(datefile, "r")
# ps has nothing to do with dates, classy xxx
ps = primes.generate_primes(10000)
dates = f.read().splitlines()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(dates, 'ro')
outputfile = ('llt.' + time.strftime('%H-%M') + '.png')
fig.savefig('./graphs/' + outputfile)
def test_generate_primes_up_to_thirty(self):
primes_result = list(primes.generate_primes(30))
assert_equals(self.known_primes, primes_result)
def test_generate_primes_up_to_one(self):
primes_result = primes.generate_primes(1)
assert_equals([], list(primes_result))
Don't forget to add two to the answer, because 2 and 5 are still primes
Performance time: ~0.52s
"""
from primes import generate_primes
from primes import is_prime
from timer import timer
timer.start()
allowed_digits = set(['1', '3', '7', '9'])
prime_iter =generate_primes()
all_primes = []
prime = next(prime_iter)
while prime < 1000000:
if len(set(str(prime)) - allowed_digits) == 0:
all_primes.append(prime)
prime = next(prime_iter)
def is_circular_prime(number):
for index in range(len(str(number))):
if int(str(number)[index:] + str(number)[:index]) not in all_primes:
return False
return True
Therefore, a heavily composite numbers will have very few divisors.
Based on that reflexion, we can say that the most composite number (the
biggest one in case there are multiples composite numbers with the same
amount of prime factors) will be the biggest n for which n / phi(n) will
give the greatest value.
Performance time: ~0.00003s
"""
from primes import generate_primes
from timer import timer
timer.start()
answer = 1
has_increased = False
while not has_increased:
has_increased = False
for prime in generate_primes():
if answer * prime <= 1000000:
has_increased = True
answer *= prime
else:
break
print(answer)
timer.stop()
Therefore, a heavily composite numbers will have very few divisors.
Based on that reflexion, we can say that the most composite number (the
biggest one in case there are multiples composite numbers with the same
amount of prime factors) will be the biggest n for which n / phi(n) will
give the greatest value.
Performance time: ~0.00003s
"""
from primes import generate_primes
from timer import timer
timer.start()
answer = 1
has_increased = False
while not has_increased:
has_increased = False
for prime in generate_primes():
if answer * prime <= 1000000:
has_increased = True
answer *= prime
else: break
print(answer)
timer.stop()
digit.
Don't forget to add two to the answer, because 2 and 5 are still primes
Performance time: ~0.52s
"""
from primes import generate_primes
from primes import is_prime
from timer import timer
timer.start()
allowed_digits = set(['1', '3', '7', '9'])
prime_iter = generate_primes()
all_primes = []
prime = next(prime_iter)
while prime < 1000000:
if len(set(str(prime)) - allowed_digits) == 0:
all_primes.append(prime)
prime = next(prime_iter)
def is_circular_prime(number):
for index in range(len(str(number))):
if int(str(number)[index:] + str(number)[:index]) not in all_primes:
return False
return True
# How many circular primes are there below one million?
from primes import generate_primes
primes = set(generate_primes(1000000))
def is_circular(n):
assert n in primes
rotations = len(str(n)) - 1
for _ in range(rotations):
n,r = divmod(n,10)
n = r*10**rotations + n
if not n in primes:
return False
return True
circular = [i for i in primes if is_circular(i)]
print len(circular)
