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_
#!/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()
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)