Sin taylor series recursive approximation

Question

I need some insight on my recursive method of calculating the sin Taylor series, which doesn't work properly. The method calls two other recursive methods which are a recursive pow method and a recursive factorial method. I compared my findings with an iterative sin method giving me the correct solution. What is missing in my recursive sin method ?

Approximation of sin(x)= x - x^3/3! + x^5/5! -x^7/7!+ ...

public class SinApprox
    {
        public static void main (String [] args)
        {
            Out.println(sinx(1, 1, 2, 1, 1, 0, 1));
            Out.print(sinIT(2));
        }

    static double sinIT(double x)
    {
        double sin = 0;
        double a = x;
        double b = 1;
        double term = a/b;
        double vz = 1;
        double i = 1;

    while(term > 0.000001)
    {
        i = i +2;
        sin = sin + (term*vz);
        a= rekursivPow(x,i);
        b = rekursivN(i);
        term = a/b;
        vz = -1 * vz;
    }
    return sin;
}

static double rekursivN(double n)
{
    if(n==1)
    {
        return 1;
    }
    return n * rekursivN(n-1);
}

static double rekursivPow(double x , double y)
{
    if(y  == 1)
    {
        return x ;
    }
    return x * rekursivPow(x , y  - 1);
}

static double sinx(double i ,double n, double x, double y, double vz, double sum, double pow)
{


    double term = pow / n;

    if(term > 0.000001)
    {
        sum = sum + (term * vz);
        vz = -1 * vz;
        i = i +2;
        n = rekursivN(i);
        y = y +2;
        pow = rekursivPow(x ,y);

        return sinx(i, n, x , y , vz, sum, pow);
    }
    return sum;


   }
}

Answer 1

Step one would be to write out the function in a way that makes the recursive relationship clear (you can't write code for what isn't clear) so, don't start with this:

sin(x)= x - x^3/3! + x^5/5! -x^7/7!+ ...

But instead, ask "how can I make all those terms with x look the same":

sin(x)= x^1/1! - x^3/3! + x^5/5! + ...

Good start, but if we're recursing, what we're really looking for is something that only computes one of those terms, and then calls itself with updated arguments to compute the next term. Ideally, we want something like:

doThing(args) {
  return simpleComputation() + doThings(updatedargs);
}

And then recursion does the rest. So let's first make sure that we only ever have to deal with + instead of a mix of + and -:

sin(x)= (-1)^0 * x^1/1! + (-1)^1 * x^3/3! + (-1)^2 * x^5/5! + ...

And now you have something you can actually express as a recursive relation, because:

sin(x,n) {
  return (-1)^n * x^(2n+1) / (2n+1)! + sin(x, n+1);
}

With the "shortcut" function:

sin(x) {
  return sin(x,0); 
}

And that's where the hints stop, you should be able to implement the rest yourself. As long as you remember to stop the recursion because a Taylor series is infinite, and computer programs and resources are not.