can anyone of you point out to me where to find lists of consecutive
primes say up to the range of the 50000th prime on the web? Reason: For
experimentally checking which prime numbers have some specific property,
I am running Maple's built-in "ithprime" function for increasingly
larger values of the counter. Maple's "ithprime" reads the first N
primes off from a list (where N is slightly larger than 30000), but as
soon as one wants to exceed these bounds, things get really very much
slowed down: Whereas the kind of test I want to do takes some 50 seconds
for the 500 primes in the range 24500 .. 25000, it takes some 10 minutes
for the 125 primes in the range 37000 .. 37125, most of which is
certainly used for finding these primes.

Any help would be appreciated.

Regards from Konstanz,

Gottfried Barthel

Fachbereich Mathematik und Statistik, Universitaet Konstanz

--
Mit freundlichen Gruessen

Gottfried Barthel

----------------------------------------------------------------------
  ___      
 /   \     Gottfried Barthel      | Tel:  [++49/0] 7531 88 27 93
|   _____  Fachbereich Mathematik | Fax:  [++49/0] 7531 88 30 36
|    |   \         und Statistik  | e-mail:                            
 \___|___/ Universitaet Konstanz  | Gottfried.Bart...@uni-konstanz.de
     |   \ Fach D 203             | WWW:      
    _|___/ D-78457 Konstanz       | www.mathe.uni-konstanz.de/
                                  |         ~barthel/
----------------------------------------------------------------------

Why not hack a sieve in a few lines of C-code?

: Regards from Konstanz,

A surprisingly simple and efficient Maple solution has been communicated
to me directly by David G Radcliffe:

   primes := array(1..50000):
   p := 1:
   for i from 1 to 50000 do
     p := nextprime(p):
     primes[i] := p
   od:

This works really well; on the SUN Ultra 10 (300 MHz) in my office, it
takes less than two minutes. The next 50000 primes take significantly
more time -- about 8 1/2 minutes --, but this is still quite reasonable.
This shows that Maple's "nextprime" is much more efficient than
"ithprime" in finding prime numbers, which comes as kind of surprise.

Regards from Konstanz,

Gottfried Barthel

this is a brief addendum to the previous message:

I just checked that at the beginning, a simple additional "if"-switch in
the code allows to speed up things considerably by using Maple's
built-in "ithprime" up to i=30000, say, instead of "nextprime":

   primes := array(1..50000):
   for i from 1 to 50000 do  
   if p <= 30000 then
     p := ithprime(i)
   else
     p := nextprime(p):
   fi;
   primes[i] := p
   od:

It thus took Maple 8 sec. instead of 53 sec. on my own Mac G3 PowerBook
with a 233 Hz CPU to go through the range up to 30000, since the values
are just read off the table. If the range does not exceed 50000 too
much, this may be worth while; for a significantly larger range,
however, these 45 sec. do not matter too much any more ...

Regards from Konstanz,

Gottfried Barthel

primes:= array(1..50000);
for i from 1 to 50000 do
  primes[i] := ithprime(i)
od:

Both ithprime(i) (if i < 100000) and nextprime(p) use very similar
strategies: they search for primes among odd numbers, starting at
p+1 or p+2 in the case of nextprime or at ithprime(i-1)+2 in the
case of ithprime.  The one difference is that ithprime checks
that the gcd of the candidate and 3929160775540133527939545
(which is the product of primes from 3 to 67) is 1 before calling
isprime, while nextprime calls isprime directly.  If ithprime(i-1)
is known (as it is in this loop), ithprime is very efficient.
Of course if you call ithprime(i) when ithprime(i-1) is not known,
it is much less efficient (and this shouldn't be a surprise), as
it has to go back to the largest j < i for which it knows
ithprime(j) and search from there.  It doesn't go all the way
back to 1, because it starts out with a remember table storing 292
values of ithprime.  But still, if you want say ithprime(49998)
it has to go check all the odd numbers from ithprime(49399)+2 =
603919 to ithprime(49998) = 611939.

Table[Prime[i],{i,1,50000}]

It took 1.6 seconds on a PIII 600 MHz Windows NT 4.0 machine for 50000.

Doing the first 100000 took a whole 3.5 seconds.

I'll email you the list if you'd like.

Wilson

In article <9k9q8m$28...@nntp.itservices.ubc.ca>, Robert Israel says...

      ithprime(22299999) = 36447497,