Comments on: Prime Numbers In Python

By: nolfonzo

nolfonzo — Sun, 10 Apr 2011 23:26:24 +0000

Tom I think you may need sqrt(n)+1

By: sanjo

sanjo — Fri, 18 Mar 2011 02:25:06 +0000

Nice one, thank you.

By: Tom Jones

Tom Jones — Sun, 19 Dec 2010 00:38:01 +0000

A for loop is even cleaner

from math import sqrt

def is_prime(n):
for i in range(2, sqrt(n)):
if n % i == 0:
return False
return True

By: Bismoy

Bismoy — Sun, 05 Sep 2010 18:21:06 +0000

gr8 stuff………..

By: nolfonzo

nolfonzo — Fri, 03 Sep 2010 18:51:59 +0000

Using Numpy and a sieve a approach you can generate these very fast. I wrote about this on my blog recently: http://rebrained.com/?p=458

import math
import numpy
def prime6(upto):
primes=numpy.arange(3,upto+1,2)
isprime=numpy.ones((upto-1)/2,dtype=bool)
for factor in primes[:int(math.sqrt(upto))]:
if isprime[(factor-2)/2]: isprime[(factor*3-2)/2:(upto-1)/2:factor]=0
return numpy.insert(primes[isprime],0,2)

By: people

people — Mon, 14 Jun 2010 16:28:31 +0000

n=input(“Enter any number-”)
if n==2:
print “prime”
if n==1:
print “neither prime nor composite”
if n>2:
for i in range(2,n):
if n%i==0:
print “composite”
break
i=i+1
else:
print “prime”
else:
print “enter correct input”

By: kotireddy

kotireddy — Fri, 09 Apr 2010 06:28:25 +0000

def isPrimenumber(number):
c=0
for i in range(number):
if number%(i+1)==0:
c=c+1
if c>2:
print number,”is not prime number”
else:
print number,”is prime number”
num=raw_input(“enter a number:”)
num=int(num)
isPrimenumber(num)

By: Veerabhadra Rao

Veerabhadra Rao — Thu, 01 Apr 2010 14:46:22 +0000

iam a iiit student in nuzvid from visakhapatnam

By: Veerabhadra Rao

Veerabhadra Rao — Thu, 01 Apr 2010 14:29:36 +0000

how are you

By: lizz

lizz — Mon, 23 Jun 2008 12:29:40 +0000

your story is sux, try to test, for example, 99999999977 or 4740914805200312594461
try to read about miller-tabin algorythm

P.S. sorry for my english

By: Johnathan Nguyen

Johnathan Nguyen — Fri, 28 Dec 2007 00:10:43 +0000

Review this publication: Prime Sequence Homology by Daniel Blake et al; Fourrier University, Grenoble

Dr. Blake’s approach is via a randomization channel. Code is also presented. I tried to cut and paste but was unsuccessful.

By: Francesc Dorca

Francesc Dorca — Thu, 06 Sep 2007 21:39:50 +0000

Hi Aaron,

First of all congratulations for your interesting blog.

Let me suggest an improvement to make your code much more efficient.

I do not know Python, but using my knowledge on other programming languages I think that I can understand your code pretty well.

You can use only integer arithmetic doing two minor changes.

Eliminate the sentence

1	import math

and replace the line

1	while i <= math.sqrt(n):

by the equivalent sentence

1	while i*i <= n:

that uses only integer arithmetics.

By: Aaron

Aaron — Thu, 06 Sep 2007 19:41:53 +0000

@Levi- Fair enough. My inexperience really shows through on things like this. I need to spend more time on math-related algorithms analyzing their complexity and what’s going on under the hood I think.

Again, thanks for the info.

By: Levi

Levi — Thu, 06 Sep 2007 18:59:50 +0000

A couple of comments regarding the complexity of this algorithm.

First, you don’t include lower-order factors in big-O notation. An algorithm that takes n-1 steps is still O(n). An algorithm that takes n^2+5n+2 steps is O(n^2), or simply Polynomial Time when speaking in terms of complexity classes.

Second, you’re ignoring the fact that, for large numbers, modulo is not a constant time operation. The O(sqrt(n)) complexity is only correct if n is the size of your number and it fits in the hardware. This isn’t true in general, so it’s not very useful for the sorts of reasoning big-O notation was invented for.

To be general, you need to define the algorithm in terms of the number of bits in your input number. For an integer N, it takes log N + 1 bits to store it. That means that the complexity in terms of the input size is O(2^(n/2)). This is exponential, i.e. very bad. A 1024 bit integer gives you a running time of essentially 2^512, which is definitely intractable.

As other people have stated, there are much better algorithms for primality testing, and the one you’re using is worthless for crypto applications.

My reference for this comment: Complexity and Cryptography: An Introduction

By: Cornelius DuLac

Cornelius DuLac — Thu, 06 Sep 2007 13:03:29 +0000

I don’t think you are using the O notation correctly. Using binary search to search through a list of n ordered numbers takes O(sqrt(n)). Here, n is not the number of inputs, it’s the input itself.

Now, if you were saying n was the size of the input number, I think you’ll find that your notation is still flawed. This is not a poly time algorithm. If it were, you would be able to break several encryption algorithms that rely on the hardness of the primality problem, as well (I believe) P=NP.

It’s been a while since I’ve done algorithmics in school, but I think you’ll find I am right.