Best method to calculate an unknown prime I'm struggling with primes...
I want to create a calculation program which need to check a number to be prime.
No problem so far!
The problem starts when this number exceeds 48 million.
The way my programming will start calculating primes is as following:  


*

*Skip 0 and 1.

*Print 2, as it is the only even prime number

*Start counting from 3 and skip all even numbers.


So far I used this method:


*

*Get the root of the number to check

*Get the remainder of the number when diving by all odd numbers till the root has been reached.


As you can guess this is pretty slow...
The reason I do not use sieves is because they are limited! I bet no one can calculate a number higher then 250 trillion to be prime with the sieve of eratosthenes. No computer can create a list counting till that number and start strikethrough numbers...
There is one choice I still have to make... Am I going to store the primes or not.
If I do I can use them to quicken the calculation process, but it will reach it limit after a few million numbers...
I was thinking of using the sieve of eratosthenes till 20 million has been reached and then jump over to another method.
The main goal is to be able to calculate primes starting at any given number till eternity. 
I founded out myself that I won't be able to use the following methods for my main goal:


*

*Sieve of eratosthenes (only partially)

*Sieve of Atkin (only partially)

*Miller-Rabin

*Mersenneprime with Lucas-Lehmertest


Please correct me if I'm wrong! And tell me then why I can use these methods.
So my question is:
How to calculate an unknown prime (since it has no limit).
Thanks in advance,
Mixxiphoid
UPDATE
I will check out the combination of Miller-Rabin with AKS.
 A: 
I bet no one can calculate a number higher then 250 trillion to be prime with the sieve of eratosthenes

That is just false.  Are you going all the way to $n$ instead of $\sqrt{n}$ when looking for factors?
The first time I ever used java, (which usually isn't noted for its computational prowess) for fun I wrote a silly program that would factor a number $n$ by checking all the odd numbers up to $\sqrt{n}$.  (This is my version of "Hello World!")  
This is strictly worse then the eratosthenes sieve, and took longest for prime numbers, but it was able to detect primality for numbers up to $9\times 10^{19}$ in less than a second.  The only reason it couldn't check larger numbers was because java's "long" only goes up to $9\times 10^{19}.$  
So if this trivial program on a old computer using java can check numbers that are $12$ orders of magnitude larger than yours, and $5$ orders of magnitude larger than your theoretical upper bound, there must be a problem with how you are implementing these methods.
Fun note: I never have forgotten that from this program, the number $1234567898765432111$ is prime.
A: Did you read this http://en.wikipedia.org/wiki/Primality_test  [*1]
especially the chapter "Probabilistic tests" which is the most practical method.
Then asking qestion about specific points from *1.
A: I am going to expand upon my previous comment and the answer of Andrei. There have been many questions on StackExchange. Recently, there was this thread which was about finding primes of a given size quickly. We also had this question, which I think directly ties into yours.
It was pretty quickly accepted that running through numbers with a couple of Miller-Rabins, and then performing the AKS algorithm on those that got through. Here, there is more information on such tests. In particular, it seems that you want to generate arbitrarily long lists of primes, and thus Miller-Rabin + AKS seems like a great start.
On the other hand, there is nothing wrong with any of the Sieves. The sieves generate lists of primes quickly, so if it's a list that you want than a sieve can be your best bet. Atkin and Sundaram are my favorites. I don't know what you mean when you say that you've determined that sieves won't work for you, because it seems to me that you just want to generate primes. Is that wrong?
A: Let's say you have 1Gb of RAM to play with. Use half of that for your base sieve, which has room for 4 billion bits. You only need to store odd primes in your sieve, so this lets you generate the primes up to 8 billion.
Now you can use the other half of RAM for a sliding sieve, using your base sieve to generate all primes p in any interval a <= p <= b with b < (8 billion)^2 = 2^66. You only need to process 8 billion of these intervals to generate all primes less than 2^66. I realise that this is not equal to infinity, which is what you seem to want. But it's certainly much bigger than 120 trillion.
Of course, you will need to program it in assembly language to get the best results.
A: Instead of:
"2.Get the remainder of the number when dividing by all ODD NUMBERS till the root has been reached."  
Try testing for divisibility of 2 and 3 and then numbers of the form (6n ± 1). This way you will not only skip the even numbers, you will also skip the numbers divisible by 3.
