Question

I have two methods: power and factorial:

public static long pow(int x, int n) {
    long p = x;
    for (int i = 1; i < n; i++) {
        p *= x;
    }
    return p;
}

public static long fact(int n) {
    long s = n;
    for (int i = 1; i < n; i++ ) {
        s *= i;
    }
    return s;
}

that are returning longs. When I want to use them in new method evaluating Exponential function i get wrong results comparing to Math.exp(x). My code:

public static void exp(int x, double eps) {
    int i = 1;
    double pow = 1.0;
    double fact = 1.0;
    double sum = 0.0;
    double temp;
    do {
        temp = pow/fact;
        sum += temp;
        pow = pow(x, i);
        fact = fact(i);
        i++;
    }
    while (temp > eps);
    System.out.println("Check: " + Math.exp(x));
    System.out.println("My: " + sum);
}

public static void main() {
    int x = 10;
    double eps = 0.0000000000001;

    exp(x, eps);
}

and the output for x=10 is:

Check: 22026.465794806718

My: 21798.734894914145

the larger x, the bigger "loss of precision" (not exactly, because you can’t really call it precise…).

The twist is, when methods power and factorial return double then the output is correct. Can anyone explain me how to make it work?

Methods pow and fact must return long and I must use them in exp (college assignment).

Answer 1

If you try this pow method:

public static long pow(int x, int n) {
    long p = x;
    System.out.println("Pow: "+x+","+n);
    for (int i = 1; i < n; i++) {
        p *= x;
        System.out.println(p);
    }
    return p;
}

You get this output:

...
Pow: 10,20
100
1000
10000
...
...
1000000000000000
10000000000000000
100000000000000000
1000000000000000000
-8446744073709551616
7766279631452241920

The long value overflows: 10^20 is just too big to fit in a long.

Methods pow and fact must return long and I must use them in exp (college assignment).

Then there is not much you can do to fix it. You could throw an exception if eps is too small.