Calculating Sine in Triangle Taylor Series

* sine.c

/* 
 * sine(x) =  x - (x^3)/3! + (x^5)/5! - (x^7)/7! ...
 */
#include <stdio.h>
#include <errno.h> /* EINVAL */
#include <stdlib.h> /* atof */

/* Function to convert degrees to radians */
double degreesToRadians(double degrees) {
    return degrees * 3.14159268979 / 180.0;
}
/* Function to calculate sine using Taylor series */
double taylorSeriesSine(double x) {
    double term = x, sum = 0.0;
    int n = 9, sign = 1;
	int power = 1, fac = 1;

    /* Initialize sum and sign */
    sum += x;
    sign = -1;
	power += 2;

    /* We calculate the first 10 terms in the series */
	for (; n--; sign = -sign, power += 2) {
        term *=  x * x;
		fac *= power * (power-1);
		sum += sign * term / fac;
    }
    return sum;
}

int main(int argc, char *argv[]) {
    double angle_degrees, angle_radians, sine_value;

    if (argc != 2) {
        printf("Usage: %s <angle_in_degrees>\n", argv[0]);
        return EINVAL;
    }
    /* Convert command-line argument to double */
    angle_degrees = atof(argv[1]);
	printf("%.2f\n", angle_degrees);

    angle_radians = degreesToRadians(angle_degrees);
	printf("%.2f\n", angle_radians);
    sine_value = taylorSeriesSine(angle_radians);
    
    printf("Sine of %.2f degrees is approximately %.6f\n", angle_degrees, sine_value);
    
    return 0;
}

 cc -g sine.c -Wall
$ ./a.out 30
30.00
0.52
Sine of 30.00 degrees is approximately 0.500000
$ ./a.out 45
45.00
0.79
Sine of 45.00 degrees is approximately 0.707107
$ ./a.out 60
60.00
1.05
Sine of 60.00 degrees is approximately 0.866025
 

Be cautious of small intermediate values when working with floating-point numbers, as they can introduce errors due to limited precision. Double precision floats in C provide a good range of accuracy, but as calculations accumulate (especially with very small or very large values), rounding errors can occur.

### Techniques to Minimize Errors:
1. **Avoid Unnecessary Operations**: As you already did, reducing redundant calculations like powers and factorials minimizes the chance of accumulating errors.
2. **Reordering Operations**: If possible, reorder operations to maintain precision. For example, multiplying small numbers together before dividing by large numbers helps avoid underflow.
3. **Precision Checks**: Add checks to avoid using terms that are near 0 or that cause the result to deviate significantly. You could implement thresholds to skip terms where further contributions to the sum are negligible.
4. **Kahan Summation Algorithm**: When summing a series of floating-point numbers, using an algorithm like Kahan summation helps to reduce the error that accumulates due to precision loss.

By being aware of these concerns and applying optimizations, you can ensure more accurate results in calculations.