Java Recursive Function?

Why would you need a recursive method any how? I think it would be better to write a simple for loop. I don't think your going to get a better performance with a recursive call.

i gave into the temptation ;-)

/**
 * Title:        <p>
 * Description:  <p>
 * Copyright:    Copyright (c) <p>
 * Company:      <p>
 * @author
 * @version 1.0
 */

import java.util.*;
public class test {

  public test() {
  }

  public static void main(String[] args) {
     int n=10;
     System.out.println("1/0! + 1/1! +...+i/"+n+"! ="+(new test()).getTotal(n));
  }

  //1/0! + 1/1! + 1/2! + .. + 1/n!
  public double getTotal(int n){
     float factorial=1;
     for(int i=1;i<=n;i++)
       factorial*=i;
     double sum=0;
     if(n>=0)
       sum=sum+(1/factorial)+getTotal(n-1);
     return sum;
  }

}

i gave into the temptation ;-)

/**
 * Title:        <p>
 * Description:  <p>
 * Copyright:    Copyright (c) <p>
 * Company:      <p>
 * @author
 * @version 1.0
 */

import java.util.*;
public class test {

  public test() {
  }

  public static void main(String[] args) {
     int n=10;
     System.out.println("1/0! + 1/1! +...+i/"+n+"! ="+(new test()).getTotal(n));
  }

  //1/0! + 1/1! + 1/2! + .. + 1/n!
  public double getTotal(int n){
     float factorial=1;
     for(int i=1;i<=n;i++)
       factorial*=i;
     double sum=0;
     if(n>=0)
       sum=sum+(1/factorial)+getTotal(n-1);
     return sum;
  }

}

Argh, that's not nice people!

As you no doubt know, a recursive method is one that calls itself to accomplish a specific purpose. The tricky part is usually to figure out when to _stop_. In these case of computing factorial values or raising a number to a power, the typical implementation when using recursion involves the method calling itself with a decremented value.

Here is an example of the factorial implemented as a recursive method.

    public static long factorial(long n) {
        if (n == 0)
            return 1;
        else
            return n * factorial(n - 1);
    }

Calling this method to compute, say the value of 5! (120 by the way), would involve the following chain of method calls to occur:

Client calls the method: factorial(5), returns 120
method calls itself: factorial(4), returns 24
method calls itself: factorial(3), returns 6
method calls itself: factorial(2), returns 2
method calls itself: factorial(1), returns 1
method calls itself: factorial(0), returns 1

This is obviously a poor implementation of factorial because, as you can see, it calls itself one too many times. The best point at which to stop would have been when the argument value was 1 as this is the point at which the computation reached identity.

As another example, here is an example implementation of the power function implemented as a recursive method.

    public static long power(long base, long pow) {
        if (pow == 0)
            return 1;
        else
            return base * power(base, pow - 1);
    }

As long as the power to which the base is being raised is >0, the method calls itself, multiplying the base by the returned value. When the pow value reaches 0, 1 is returned. This handles the case that the method is originally called by a client with a pow of 0.

Using these as examples, you should be able to complete the implementation of a recursive method that uses the inverse of factorial to approximate e.

Best regards,
Jim Cakalic

What's the purpose Jim? He already has his answer, he'll just copy it and give it to the teacher...

Nice answer Jim.  The cat was out of the bag anyway, and as usual you provided a wonderful explanation without leaving anything out.

Laminamia :)

Come on people! This is not homework. My dad is a programmer and he told me if could program this, he will buy me a new computer! Thanks all!! WOOOOHOOOOO! PENTIUM 600 here I come!

Come on people! This is not homework. My dad is a programmer and he told me if could program this, he will buy me a new computer! Thanks all!! WOOOOHOOOOO! PENTIUM 600 here I come!