How can I compute a very precise value for e?

Question

So I've been looking around for a good algorithm to compute a very precise value for e. All the algorithms I've found all use a derivative of the old summation from 1->n of 1/n!. And this is accurate, however I need to calculate e out to several thousand decimal places and you simply cannot accuratly represent something of that precision with a common floating point variable.
Basically what I need is a method to seqentially calculate one decimal place at a time, or some kind of spigot algorithm where I can calculate a single nth decimal place. I've tried googling and searching these forums without any luck. I know there are spigot algorithms for PI and that there are ways to relate PI to e so maybe I'll have to use a combination of those. Anyone got any ideas?

Answer 1

No it is not at all difficult to find the prime. And forgive me for being overly terse and jumping to conclusions in my posts. If I am wrong in my assumptions, I apologize. For thoses of you that are not following any of this, here is the back story:
I read in the newspaper yesterday that someone had placed a billboard ad that was a puzzle somewhere in sillicon valley specifing something like
[the first 10 consecutive digits in the decimal expansion of e that form a prime].com
I don't live in California and have not seen the ad and may have mis quoted it.
The article went on to say that Google had placed the ad, and that if you get the proper number and type it in you get to page that lists another puzzle. If you follow the chain of puzzles to the end you get an invite to submit a resume to Google.
I look at the forms this morning and find a post from someone that was thinking about needing e out to a large number of digits. When a practical method was suggested in the reply the OP points out that this is not for some "practical" purpose but for some "theoretical" purpose. I jumped to the conclusion that this was someone that wanted to solve the puzzle but didn't want to work to hard to do it.
My comments that the first 10 digit prime is 99 digits into the expansion it quite possibly irrelevant to the OPs original question. If there was some other "theoretical" purpose that requires some 800 Million digits of e, I apologize for my assumptions.
On the other hand if the OP just wanted to solve the Google puzzle, why not come clean, admit it, and tell us the problem that you want to solve rather than beating around the bush with nonsense about needing an algorithm that pops out the nth digit of e. I've already given you the spoiler of where it is in the expansion of e, If you want the rest of the spoiler, like what the digits are, and what the answer to the next question is as well, just ask.
Here is the BigInt Code
    BigInteger fac = BigInteger.ONE;
    BigInteger n = BigInteger.ONE;
    BigInteger scale =(new BigInteger("10")).pow(200);
    acc = scale; // this is the n=0 term because 0!=1
    int numTerms = 0;
    boolean done = false;
    while(!done){
      BigInteger nextTerm = scale.divide(fac);
      acc = acc.add(nextTerm);
      numTerms++;
      if (nextTerm.equals(BigInteger.ZERO)) done = true;
      //System.out.println(numTerms+":fac"+fac);
      n = n.add(BigInteger.ONE);
      fac = fac.multiply(n);
    System.out.println("Number of terms:" + numTerms);
    System.out.println("e to about 200 digits:" + acc);Go nuts!