Thread: Sine (Sin) Algorithm Help

Originally Posted by StaticKyle

Okay, I implemented yours, laserlight, and I tested it and the answer that I got with setting the loop count or n to 15 wasn't close to the value that I got from my calculated value.

well in that case try this

Code:

double sine(float x)
{
  int i,n;
  int sign = -1;
  double sum = x,power=x,fact = 1.0,psum=0.0;
  for (i = 1; fabs(fabs(sum) - fabs(psum)) > 0.0000000001; ++i)
  {
    psum=sum;
    power = power * x *x;
    n = (2*i+1); 
    fact = fact * n * (n-1); 
    sum += sign * power/fact;
    sign = -sign;
  }
  printf("n value is %d\n",i);
  return sum;
}

the angle is expressed in radians ,Am i right?

sin(45 radians)=0.8509
sin(45 degrees)=0.7071

What I meant to say was: Maybe your calculator is in radian mode.

That's good. What is your current working solution?

It probably isn't efficient, but it is due tomorrow, and so I did what I could.

Well, it's better to try than to be spoonfed.

If you are interested, my answer follows. If it is still not yet past your deadline, I hope that you have the honesty not to copy

Consider the sine computation expressed in summation notation:
From n = 0 to infinity
sine(x) = sum of (-1)^n * (x^(2n+1) / (2n+1)!)

(-1)^n just gives us the sign of the term, so it is not so interesting. What is interesting is the term itself, excluding the sign. As mentioned, it is expensive to calculate the power and the factorial on each iteration, and we risk overflow. What we can do is express the term in relation to the previous term, i.e., a recurrence relation:

0th term = x
nth term = (n-1)th term * (x^2 / (2n * (2n+1)))

Now, x^2 is a loop invariant: it does not change on each iteration. (2n * (2n+1)) is relatively quick to compute and will not overflow unless n is large. Consequently, (x^2 / (2n * (2n+1))) tends to 0 as n tends to infinity. So, all we need to do is keep looping as long as (x^2 / (2n * (2n+1))) is greater than 0.000001.

As such, a solution presents itself:

Code:

#include <stdio.h>

const double EPSILON = 0.000001;

double sine_nonneg(double x)
{
    double term = x;
    double sum = x;
    int sign = -1;
    double x_squared = x * x;
    int i;

    for (i = 1; term > EPSILON; ++i)
    {
        term *= x_squared / ((i + i) * (i + i + 1));
        sum += sign * term;
        sign = -sign;
    }

    return sum;
}

double sine(double x)
{
    return x < 0.0 ? -sine_nonneg(-x) : sine_nonneg(x);
}

int main(void)
{
    printf("&#37;f\n", sine(-12.34));
    return 0;
}

I chose to use the sine_nonneg function so as to more easily handle the sine of a negative angle by having sine_nonneg compute the sine of the corresponding non-negative angle.