Java program gives incorrect Taylor series term for function e^x

Question

//java program that asks the user  to input a number that e^x=1+x+x^2/2! +x^3/3!... e is a mathematical constant equal to 2.718...

import java.util.Scanner;
public class taylor_2 {
  public static void main(String args[]) {
    Scanner input=new Scanner(System.in);
    double x; //input for x
    double factorial=1; //initializes factorial
    int counter=1; //initializes counter
    double result=1; //initializes result

    System.out.println("Enter non negative number"); //asks user to enter x
    x=input.nextInt();

 //output in while loop will continue to be generated if user doesn't entered a negative number

    while(x<1){
      System.out.println("I said entered a positive number");
      x=input.nextInt();
    }
    while(x>counter){
      factorial=factorial*counter;//factorial formula
      result=result+(Math.pow(x,counter))/factorial; //equation for e^x=1+x+x^2/2! +x^3/3!
      counter++;
    }
    System.out.println("Taylor series is " +result);//output for taylor equation e^x
  }
}

Here is the output of my code:

Enter non negative number

2

Taylor series is 4.0

When I entered 2 , it should have outputted 7.3890560983 instead of 4.0 since e=2.718... and e^2=7.3890560983. What am I doing wrong?

Answer 1

The problem is that the Taylor series is not the same function that e^x. It will return a function that is close to the function e^x.

For understanding it better, I recommend you to look the second picture of the next link:

https://en.wikipedia.org/wiki/Taylor_series

You can see in the previous picture that as n is getting larger the function is getting more accurate.

Your code's problem is that your x value is your n value, and this is not really true.

x: Must be the value you want to now e^x.

n: Is the accurate of your equation. Larger means more accurate.

So you must change while(x>counter) with while(n>counter) , where n can be either a variable with the user selected accuracy, or a constant with your selected accurcy.

I think that until x=100 , n=150 should work.

I hope that helps you! :)

Answer 2

There seems to be an answer here: EXP to Taylor series for c++, even though the algorithm is slightly different to yours. Here's its Java version:

public class TaylorSeries {
public static void main(String args[]) {
    Scanner input = new Scanner(System.in);

    System.out.println("Enter x:");
    double x = input.nextDouble();

    double result = calcExp(x);
    System.out.println("calcExp(x) = " + result);
    System.out.println("       e^x = " + Math.pow(Math.E, x));
}

static double calcExp(double x) {
    double eps = 0.0000000000000000001;
    double elem = 1.0;
    double sum = 0.0;
    boolean negative = false;
    int i = 1;
    sum = 0.0;

    if (x < 0) {
        negative = true;
        x = -x;
    }

    do {
        sum += elem;
        elem *= x / i;
        i++;
        if (sum > Double.MAX_VALUE) {
            System.out.println("Too Large");
            break;
        }
    }
    while (elem >= eps);

    return negative ? 1.0 / sum : sum;
}
}

The output:

Enter x:
2
calcExp(x) = 7.389056098930649
       e^x = 7.3890560989306495

All credit should go to the answer here: EXP to Taylor series . I have only converted c++ code to Java