Value of a variable not changing in a loop - c

Question

I have a function that calculates the sin() of a radian angle. It takes two parameters, the value of the angle in radian and the terms. Just to make everything clear, this is how sin() is calculated:
sin(x) = x - (1/3! * X^3) + (1/5! * X^5) - (1/7! * X^7) + (1/9! * X^9) - ...
This is the function that do this calculation:
double sinx(double theta, int terms) //Theta is the angle x in radian
{
double result = 0;//this variable holds the value and it's updated with each term.
int i = 1;
int num = 3;
while(i <= terms-1)
{
if(i % 2 != 0){
result = result - ( (1.0/factorial(num)) * pow(theta, num) );
printf("if\n");//this is just for debugging
}
else if(i % 2 == 0){
result = result + ( (1.0/factorial(num)) * pow(theta, num) );
printf("else if\n");//this is for debugging too
}
printf("%lf\n", result);//debugging also
num = num + 2;
i = i + 1;
}
return theta + result; //this calculates the final term
}
The problem is the variable result's value doesn't change. Which also results in the final result not changing when using different number of terms.
Those are some outputs I get:
//with theta = 0.2 and terms = 6 ;;
if
-0.001333
else if
-0.001331
if
-0.001331
else if
-0.001331
if
-0.001331
Computed Sin<0.200000> = 0.198669. //this is the returned value. It's printed in the main
//with theta = 0.2 and terms = 7
if
-0.001333
else if
-0.001331
if
-0.001331
else if
-0.001331
if
-0.001331
else if
-0.001331
Computed Sin<0.200000> = 0.198669.
Any ideas?

Answer 1

Your code should be totally right. At least my calculator gives the same result.
If you change your printf("%lf\n", result); to printf("%.17f\n", result); you get this output:
if
-0.00133333333333333
else if
-0.00133066666666667
if
-0.00133066920634921
else if
-0.00133066920493827
if
-0.00133066920493878
else if
-0.00133066920493878
Now you can see, that it is still changing in every loop, but very little.

Answer 2

Really it converges fast so for double precision there is no difference between 6 and 7 terms. Here is the dump with better precision:
if
-0.00133333333333333350
else if
-0.00133066666666666680
if
-0.00133066920634920640
else if
-0.00133066920493827170
if
-0.00133066920493878470
Sin(0.2, 6) = 0.19866933079506122000
if
-0.00133333333333333350
else if
-0.00133066666666666680
if
-0.00133066920634920640
else if
-0.00133066920493827170
if
-0.00133066920493878470
else if
-0.00133066920493878450
Sin(0.2, 7) = 0.19866933079506122000

Answer 3

Everything looks correct here. The reason the result doesn't appear to change is to do with how quickly the Taylor series for sin converges for small angles. If you try with a bigger number say pi you should see the value updating slightly more often. You may also want to include something to limit theta from -pi to +pi as sin is a periodic function.
theta = mod(theta+pi, 2*pi) - pi
Including this restriction will alleviate the need for more terms if you start calculating values > pi or < -pi
If performance is important then you can reduce some of the calculations by removing repeats in calculating the factorials and large exponents
double sin(double theta, int terms = 7)
{
theta = mod(theta+pi, 2*pi) - pi;
double sum = x, term = x, fact = 3;
for (int i = 1; i < terms; i++)
{
term = -term * theta * theta /(fact * (fact - 1));
sum += term;
fact += 2;
}
return sum;
}

Answer 4

Your program as you have posted seems quite right IF you have your factorial written the right way. I have written factorial this way:
double factorial(int n) {
if(n <= 1) {
return 1.0;
}
else {
return n * factorial(n-1);
}
}
Try using this.
Using 0.785398 (approx. pi/4) and 10 terms, I get output 0.707107.
double d = sinx(0.785398, 10);
printf("%f\n", d); // prints 0.707107
Here are some runs:
printf("%.20f\n", sinx(3.1415926535897932, 100));
printf("%.20f\n", sinx(3.1415926535897932/2, 100));
printf("%.20f\n", sinx(3.1415926535897932/4, 100));
Outputs:
0.00000000000000044409
1.00000000000000000000
0.70710678118654746000
which seem accurate enough, given the pi used is only approximate.

Answer 5

What did you expect ?
The third term is
0.2^5/120 = 0.000002
if you show the first six decimals, and the next terms are yet smaller.
Side remark:
It is much more efficient and more accurate to compute a term from the previous, using the recurrence
T*= Z/(N*(N-1))
where Z= -X*X (and this way, the alternating signs are automatically handled).