It is quite complicated, section 2 deals with the performance of the naive algorithm and 3 implements the sieve properly. I could not quite grok the Haskell but the following quote helped me know what was going on

Whereas the original algorithm crosses off all multiples of a prime at once, we perform these “crossings off” in a lazier way: crossing off just-in-time. For this purpose, we will store a table in which, for each prime p that we have discovered so far, there is an “iterator” holding the next multiple of p to cross off. Thus, instead of crossing off all the multiples of, say, 17, at once (impossible, since there are infinitely many for our limit-free algorithm), we will store the first one (at 17 × 17; i.e., 289) in our table of upcoming composite numbers. When we come to consider whether 289 is prime, we will check our composites table and discover that it is a known composite with 17 as a factor, remove 289 from the table, and insert 306 (i.e., 289+17). In essence, we are storing “iterators” in a table keyed by the current value of each iterator.

Here it is using a dictionary for each composite number with a list of increments it was reached by:

from itertools import count

def gen_primes():
    yield 2
    def update_composites(number,increment):
        try:
            composites[number] += [increment]
        except:
            composites[number] = [increment]

    composites = {4:[2]}

    c = count(3)
    while 1:
        #print composites
        next = c.next()
        smallest = min(composites.keys())
        incs = composites[smallest]
        del composites[smallest]
        for inc in incs:
            update_composites(smallest+inc,inc)
        if next < smallest:
            yield next
            c.next()
            update_composites(next**2,next)

g=gen_primes()

for i in range(100):
    print g.next()

(On Github)

They mention a speedup moving to a heapqueue as the data structure (as we just take the lowest each lookup) so I implemented that too, here is the code

from itertools import count
from heapq import heappush,heappop

def gen_primes():
    yield 2

    def update_composites(number,increment):
        heappush(composites,(number,increment))
    composites = [(4,2)]

    c = count(3)

    while 1:
        #print composites
        smallest,increment = heappop(composites)
        update_composites(smallest+increment,increment)
        if composites[0][0] == smallest:
            continue
        next = c.next()
        if next < smallest:
            yield next
            c.next()
            update_composites(next**2,next)

g=gen_primes()

for i in range(100):
    print g.next()

(On github)

Share on Facebook

If p is the perimeter of a right angle triangle with integral length sides, {a,b,c}, there are exactly three solutions for p = 120.
{20,48,52}, {24,45,51}, {30,40,50}
For which value of p < 1000, is the number of solutions maximised?

WARNING: CONTAINS MATHEMATICS

You may remember from school



(Difference of 2 squares)
let

and

so


and substituting these into
gives

Set and to get rid of that root and you have

Primitive triples are ones in lowest terms (if you know (3,4,5) you can get (6,8,10) etc by multiplying each side by some integer)
If p and q are coprime and different parity you just get primitive ones (i did not bother and just used set() to remove dupes from the list)

Here is my code

from __future__ import division
from collections import defaultdict
from time import time
     start = time()
counter = defaultdict(list)
    def triples():
    for q in range(1, 35):
        #35 is greater than sqrt(1000)
        for p in range(q+1, 35):
            a = p**2 - q**2
            b = 2 * p * q
            c = p**2 + q**2
            for m in range(1,int(1000/c)):
                #generate multiples till c is above 1000
                #triples with perimeter > 1000 are filtered later
                yield (m*min(a,b),m*max(a,b), m*c)
    for triple in triples():
        perimeter = sum(triple)
        if perimeter < 1001:
        counter[perimeter] += [triple]
<p>print set((counter[120]))
<p>maxlen = 1<br />
for i in counter:
    length = len(set(counter[i]))<br />
    if length > maxlen:<br />
        maxlen = length<br />
        print i<br />
end = time()</p>
<p>print "took ", end-start</p>
<p>

Which outputs:
set([(24, 45, 51), (20, 48, 52), (30, 40, 50)])
520
528
630
660
720
840
took 0.0140960216522

I tried brute forcing it today and knocked up the following

<br />
from collections import defaultdict<br />
counter = defaultdict(int)<br />
from time import time</p>
<p>def run():<br />
	start = time()<br />
	for perimeter in range(1,1001):<br />
		#print perimeter<br />
		for a in range(1,perimeter):<br />
			for b in range(1,perimeter-a):<br />
				c = perimeter - a - b<br />
				if a**2 + b**2 == c**2:<br />
					counter[a+b+c] += 1<br />
	mosttriples = 0<br />
	for i in counter:<br />
		if counter[i] > mosttriples:<br />
			mosttriples = counter[i]<br />
			print i<br />
	end = time()<br />
	print "TOOK", end-start</p>
<p>print "without psyco"<br />
run()</p>
<p>print "with"<br />
import psyco<br />
psyco.full()<br />
run()<br />

Which gives

without psyco
516
520
528
630
660
720
840
TOOK 134.663383007
with
516
520
528
630
660
720
840
TOOK 21.0988409519

So psyco makes it 6 times faster but a smarter algorithm is 2000 times faster still.

Share on Facebook

You may think “trips abroad for kids, great” , if you are more cynical you may think “heads choose the kids, not sure I like that”.

Let us do some arithmetic, 100 kids for 6 weeks each for £1.4M.

• £1400000/100 = £14,000 per child
• £14000/6 = £2’333 per week
• Assuming a 40 hour working week, £58/hour

Of course its not that simple, the kids clearly don’t get all the money as if they had a 6 week job. I think a few marketeers in the UK, all the necessary admin by the British Council will do away with some of the money too, but I can’t imagine any way this is good value for the country or any organisation involved (I am not cynical enough to suggest that for the BC the point is to administer it.)

Hows about giving 1000 kids £1000 spend in a country of their choice, you could get them to bid for the money and report back with diaries and photos etc. All the £500′s the government paid into child trust funds for children with low-income parents could become a good jolly fund for them when they hit 18, or they could get driving lessons and a car – not a bad deal, particularly if their folks contribute anything else to the fund along the way. That or 18th birthday parties become 5 day benders in estates around Britain.

Share on Facebook

You know its real bad when you get home, do the calculation and and are disappointed you did not say 11.5 and then blog about it.

Share on Facebook

Share on Facebook

The one I am excited about most is for SAGE. SAGE is written in python and leverages the hard work of the other projects (its motto is Building the Car Instead of Reinventing the Wheel). See the TeXmacs plugin here and some screenshots of SAGE here.

I will take a look at the code and see if I can contribute anything, it will be nice to get involved in a big project.

Share on Facebook

I stumbled across a site that reminded me of when I used to read tomshardware to see how fast new PC parts really were (or look at nice graphs and read a conclusion telling me). Their benchmarks of Ubuntu vs Fedora and The Last 12 Linux Kernels strike me as pretty pointless. Pages of graphs saying things are the same bar noise, as you would probably expect. The conclusion of the distro shootout at least says you should (could?) not base your decision on the results. The Linux one is interesting:

The only benchmark where there was a definitive improvement was with the network performance. Granted, these 12 Linux kernels were only tested on one system and in eight different benchmarks. We will continue benchmarking the Linux kernel in different environments and report back once we have any new findings.

Of all the benchmarks, I would have predicted in advance that the network one would be noisiest. I would suggest that you would get different results on different machines, perhaps they should use different clocks too.

Do these people creating the graphs know about repeating measurements, averaging and statistical significance tests? I think not, so what is the point?

Share on Facebook