Project Euler

I’ve recently come across a nifty page known as Project Euler. It’s filled with over 230 math related programming problems to solve. Don’t worry if your math is rusty, most of the problems can be brute forced easily enough, but knowing some math can certainly help make your programs faster. Trying to find all the divisors of a number for example, will crawl to a halt when you get to large numbers, but there’s a shortcut to find the result of the divisor function just by the prime factorization of a number. This will help solve one of the problems in about .8 seconds instead of about 20 minutes of computation.

Most of my solutions are very hacked together and brute force, but they work well enough. I’ve been focusing more on solving each problem quickly and correctly, rather than coming up with the best code, resulting in a lot of code that falls into the burn after compiling catagory. I’ve been doing most of them in C, but some I’ve resorted to Java and other languages to make things easier, or to reuse code (there’s one challenge to write a program to solve Su Doku puzzles, something I wrote in Java and mentioned here).

If I come up with a particularly ingenious solution to one of them I might post it here. I’m current finishing up the 14th problem (doing them mostly in order).

A Programmer’s Quest for Primes: Part 4 – Special Primes

Continuing my playing with primes, I’m now up to having 1 billion of them sitting on my hard drive. That’s 11GB in a text file. It’s actually spread out between 10 files in 100 million prime blocks to load in an out of RAM easier. They were generated in only 30 minutes using the Sieve of Eratosthenes and a modified version of the prime program found here, http://www.troubleshooters.com/codecorn/primenumbers/primenumbers.htm.

In this post I went through my files finding some statistics on special primes. The graphs below have groups of 1 million primes on the x-axis, and the number of special primes found within that 1 million on the y-axis.

Twin primes: prime numbers that differ by two. For example, 17 and 19. There are theories that there are an infinite number of twin primes, but looking at it as a limit as the function approaches infinity, it certainly looks like it goes to 0, if very slowly. In the first 1 billion primes, there are 58,047,180 twin primes (according to my program’s results at least), or about 5.8% of the total.

Cousin primes: prime numbers that differ by four. Interestingly, according to some number theory equations called the Hardy–Littlewood conjecture, they are supposed to have about the same distribution as twin primes. My results show it’s quite close, 58,040,262 of them in the first billion primes. The graph is about the same.

Sexy primes: no, I didn’t come up with the name, the Latin word for 6 is sex, and the math people love to name things in Latin and use Greek symbols. Primes that differ by 6. There are 105,002,853 of them in the first billion, quite a bit more than twin or cousin primes.

Answer primes: pairs of primes that differ by 42. Okay, I did make this one up. Any scifi fans out there will see the reference. There are 22,729,810 of them in the first billion primes. The graph is at least more interesting than the others due to the fact it’s a larger number. The distance between primes increases as the primes gets bigger.

Some random facts of interest (to weird people like me anyway).

The longest distance between two primes out of the first billion (consecutive composite integers): 394. There are no prime numbers between 22367084959 and 22367085353. If you split the 1 billion primes into blocks of 1 hundred million, and then find the longest runs of composite integers in each block,

292 between 1453168141 and 1453168433
336 between 3842610773 and 3842611109
354 between 4302407359 and 4302407713
340 between 8605261447 and 8605261787
382 between 10726904659 and 10726905041
354 between 11705477863 and 11705478217
346 between 14066075347 and 14066075693
376 between 16161669787 and 16161670163
372 between 20404137779 and 20404138151
394 between 22367084959 and 22367085353

Since the distance on average between primes increases as you get bigger, you’d think the max distance would increase more clearly. Such is one of the mysteries of the primes.

A Programmer’s Quest for Primes: Part 3 – Prime Distribution

While playing around with primes and C some more, I put together some plots with Mathematica dealing with the distance between primes. The prime numbers are plotted, with the n’th prime on the x-axis and the difference between it and the last prime on the y-axis. After all, I’ve got gigabytes of primes sitting around.. got to figure out something to do with them other than test my RAM while generating them.

The first 1,000 primes,

Of course, primes can’t be odd numbers apart, because that would make them even. That explains the pattern a bit. Still, for something that has baffled mathematicians for centuries, it certainly does seem like there’s a pattern to it. If you draw lines between the points,

Certainly not as pretty.

The first 10,000 primes,

The scale makes this one a bit less interesting. Too much overlap, but Mathematica really doesn’t like big listplots like this. I even crashed it a few times when I tried to do a listplot of 100,000 data plots. 10,000 was pushing it.

A random sampling of 1,000 primes (between the 90 millionth and 90 million 1 thousandth prime),

More interesting patterns in primes, the Ulam spiral. Starting at 1 and spiraling outwords from the orgin, you create a graph like so (http://en.wikipedia.org/wiki/Ulam_spiral),

And then remove all but the primes (http://en.wikipedia.org/wiki/File:Ulam-Spirale2.png),

And you find an intersting pattern, that the prime numbers tend to lay along some diagnols more oftan than others. Expanding this to 150,000 primes,

A Programmer’s Quest for Primes: Part 1 – Brute Force

While trying to come up with something to program, I looked to prime numbers in my discrete math class and decided to make a simpler prime number calculator. The deeper I delve into the world of prime numbers the more interested I become. The building blocks of all numbers with plentiful applications in cryptography have captured my spare time recently. This is part 1 of my quest for calculating prime numbers. I have no real goal in this quest, other than to expand my knowledge of mathematics and sharpen my skills of programming; it’s the journey that matters, not the destination.

First off some math. What is a prime number?

Prime Number: A positive integer p greater than 1 is called prime if the only positive factors of p are 1 and p. A positive integer that is not prime is called composite.

For example, 42 is not prime, it can be written as the product of the factors 2 and 28. 28 isn’t prime either, it can be written as 2*14. 14 can be written as 2*7. What can 7 be written as? or 2? Nothing, these are primes. Now a useful theorem.

Fundamental Theorem of Arithmetic: every positive integer greater than 1 can be written uniquely as a prime or as a product of two or more primes.

That means 42 can be written as 2*2*2*7, all of which are prime numbers. 105 can be written as 3*5*7, all prime.

Now, how can you tell of a number is prime? Well, if the number is composite, that means it can be divided by some prime number. You can keep a list of prime numbers and then try and divide that number by them all. If it doesn’t divide by any prime numbers, it’s prime itself. For example, we find a list of prime numbers: 2, 3, 5, 7, 11. Now suppose we want to see if the number 13 is prime. We’d do the following,

13 % 2 == 0? If so prime.

13 % 3 == 0? If so prime.

13 % 5 == 0? If so prime.

13 % 7 == 0? If so prime.

13 % 11 == 0? If so prime.

None of these numbers can divide 13, so 13 is prime. When we get into prime numbers like 576,194,557 though, this process will be doing millions of checks on the prime numbers found before, which will be horribly slow.

A quick way to make a huge speed difference is use another handy theorem.

Theorem: If n is a positive composite integer, then n has a prime divisor less than or equal to sqrt(n).

So rather than checking if 576,194,557 is divisible by each prime found before it, we can just check if it’s divisible by any of the primes less than or equal to 24,004.

Before getting down to the programming, one more quick way to make it more efficient is to count by 2’s, since we know all prime numbers are odd. In fact, prime numbers always end in either 1, 3, 7, or 9. Increasing the number you’re checking for primeness by 2 every time can eliminate checking anything that ends with 0, 2, 4, 6, or 8.

Therefore,  a simple brute force method for finding primes: create an array (in the heap, because the stack will overflow), and store all the primes you find in it. Increase your candidate number by 2, try to divide it by all the primes in the list, and break out of the loop if you find a number that divides it or if you reach a prime larger than sqrt(candidate). The latter means it’s composite and the former means it’s prime. Keep doing this until you find as many primes as you like. My source code for such a program written in ANSI C can be found here, http://pherricoxide.jumbofx.com/code/simpleprimecalc.c. It’s well commented and should compile with any ANSI C compiler. This is the first of hopefully several prime calculators I’m going to write.

Using this program on a 1.4ghz Intel Core 2 Duo with 2GB RAM, the first 100 million primes are found in about 137 minutes.

The problem is, as the numbers get bigger, this program runs slower and slower. The graph below shows time plotted on the horizontal axis and number of primes found plotted on the vertical. You rapidly find primes in the beginning, but after a while it will inevitably take you long minutes just to find a few primes. Using this method, we hardly have to worry about running out of RAM, because by the time we get 2GB of data (around 200 million primes), the process will be going so slowly it will hardly be worth continuing the search, at least using this brute force method.

Stay tuned for faster prime calculations with better code, better algorithms, and someday perhaps even some cluster computing, as I continue my quest for primes. Until then, here are some prime numbers to spot check your own prime calculating programs with.

1 millionth prime: 15,485,863 (found in 7 seconds)

5 millionth prime: 86,028,121 (found in 112 seconds)

10 millionth prime: 179424673 (found in 5 minutes)

20 millionth prime: 373,587,883 (found in 12 minutes)

30 millionth prime: 573,259,391

40 millionth prime: 776,531,401

50 millionth prime: 982,451,653 (found in 50 minutes)

60 millionth prime: 1,190,494,759

70 millionth prime: 1,400,305,337

80 millionth prime: 1,611,623,773

90 millionth prime: 1,824,261,409

100 millionth prime: 2,038,074,743 (found in 137 minutes)

Pondering on the Teaching of Mathematics

As I sit here working on calc III homework, I come to the realization once again that I really have no idea what I’m doing.

On one hand, I know exactly what I’m doing. I’m taking double integrals, finding Lagrange multipliers, and finding partial directional derivatives. I can tell you what these terms mean, which make any non-engineering or math major cringe, easily enough. They’re volumes under surfaces, a handy way to find max/mins, and lines tangent to surfaces in a direction. They’re actually not even hard to do, it’s just all the stuff you learned (or learned and forgot often in my case) in calc I and calc II applied to R^3 space.

On the other hand, I have no idea what I’m doing. How would I ever use this in the real world? Just trying to figure out an application is difficult. Don’t start attacking me saying there’s applications for this kind of math all over the place, because I’m trying to believe you, I really am. I just haven’t been taught any of them. Say I have a function f(x, y), and then I want to see how the function changes with respect to x only. Okay, sure, just take a partial derivative. Why would I want to find how the function changes at an angle of 42 degrees from a point though? For that matter, where do these functions come from? How do I model real world applications into the form f(x, y) so I can easily do my calc on them? If you look at the Wikipedia article for a hyperbolic paraboloid, there’s 4 sections of it’s properties and how to do stuff with it, and a footnote at the bottom saying “applications: directional antennas and receivers, such as satellite dishes, telescope mirrors, and directional microphones are paraboloids.” Nifty, why don’t they ever give me cool application problems dealing with directional antennas?

If I get a job in engineering or math, I don’t think my boss is going to come up to me and say, “hey, go find the first and second order derivatives of .” First off, I can plug that into Mathematica and get the answer in a few dozen clock cycles, faster than I can even write the first derivative with respect to x. For that matter, faster than I can write the letter ‘x’.

The really sad part is, I’m in “applied” linear algebra and calculus “for engineers”. That means somewhere at ASU there’s a bunch of math majors even more clueless about the applications of what they’re doing, even if they can prove by contradiction that their numbers are at least logically derived.

If I ever became a math professor, this is what I’d do. First off, instead of spending the first class introducing myself and the syllabus, I’d spend it introducing the subject. I’m 4 weeks into discrete math right now and I still have no idea what discrete math really is. It seems like a hodgepodge of topics and mainly a class to teach proofs in, which seems a bit pointless since the teacher said a good 50% of the material overlaps with the class I’m taking next semester on proofs. Don’t go into details about how to do anything, just talk about the general idea of the stuff. If teaching calc I, explain what derivatives and integrals are from a geometric viewpoint. Explain a few basic uses of them as well. Don’t just jump into the limit definition.

Then, when you get into the material, first play around with some problems and applications before you dive into a proof of some formula that takes half the class. This would at least show the students where you’re going during your proof. More often than not I watch my teachers manipulate expressions for 5 minutes, coming up with an obscure formula, then explaining what the formula actually does. If I’m really lucky, they’ll even explain what it means after that.

Finally, once you know the formula, where it came from, and what it does, do real world problems. If almost all the problems are related to physics, maybe physics and math should be combined into one class. It seems like physics classes just apply formulas to problems, and math classes just make up formulas without showing any problems. It’s hard to deny that a large part, maybe even the majority of uses for calculous involve physics. Of course the classes would move slower, but what’s wrong with spending more semesters if you’re combining two classes?