Help: "no exact representable decimal result"

Question

I have a program which calculates the value of e, however it will not let me increase the accuracy of the calculation. Currently it is only accurate to about 5ish places and caps out with an error. I thought BigDecimal would allow me to do this type of operation. What am I doing wrong?
import java.math.*;
public class Main {
    public static void main(String[] args) {
        BigDecimal num = new BigDecimal(25000); //bigger the number, the harder and more accurately e is calculated
        BigDecimal finl = (BigDecimal.ONE).add(((BigDecimal.ONE).divide(num))).pow(num.intValue());
        System.out.println(finl.toString());
//My testing of diffrent values for "num":
//10,000 == ~1 second
//25,000 == ~8 seconds
//50,000 == ~31 seconds
//75,000 == BUG: "Non-terminating decimal expansion; no exact representable decimal result." :(
Edit Here is the exact error when I use a large number like 75000:
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.math.BigDecimal.divide(BigDecimal.java:1514)
at Benchmark.Main.main(Main.java:8)
Java Result: 1
Edited by: kavon89 on Apr 16, 2008 12:01 AM
Edited by: kavon89 on Apr 16, 2008 12:03 AM

Answer 1

After sifting through the API some more, I've found MathContext fixes the inefficiency. Under a second to complete the process with an added precision/MathContext thing is just as accurate.
I'm finding that it's not just the large size of the number, but just a specific number that causes it to throw the error mentioned above. For example, 75000 was what I kept trying and getting an error with, but when I tried 80000 it worked.
Well, now that it's not the size of the number, lets just shoot in the dark and get more accuracy!
import java.math.*;
public class Main {
    public static void main(String[] args) {
        String reallybig = "50000000000";
        BigDecimal num = new BigDecimal(reallybig); //bigger the number, the harder and more accurately e is calculated
        MathContext prsc = new MathContext(20);
        BigDecimal finl = ((BigDecimal.ONE).add((BigDecimal.ONE).divide(num))).pow((num.intValue()), prsc);
        System.out.println(finl.toString());
Exception in thread "main" java.lang.ArithmeticException: Invalid operation
        at java.math.BigDecimal.pow(BigDecimal.java:1932)
        at Benchmark.Main.main(Main.java:10)
Java Result: 1Great, a new exception. This time looking at the source of BigDecimal shows why:
    public BigDecimal pow(int n, MathContext mc) {
        if (mc.precision == 0)
            return pow(n);
        if (n < -999999999 || n > 999999999)
            throw new ArithmeticException("Invalid operation");So now I know I can't raise a BigDecimal to a number greater than 999999999.
My code is meant to be used in a benchmark and I can barely get 20 decimal places of accuracy with e. Is Java just incapable of this "heavy duty math" that takes less than a second to compile or should I use a different approach?