My_sine: what is wrong with my function? [closed]

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center. Closed 10 years ago.

Okay, so I have tried everything I could think of and haven't been able to figure out how to get this program working. I have tested all the functions used in the main, but included them anyway just in case there is some bug in them. More than likely though, I believe my mistake is in the main.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.14159265359

double int_power(double x, int e);


int main()
{
    int my_factorial(int n);
    double my_sine_taylor(double x);
    double my_sine(double x);
    double mod_two_pi(double x);
    double get_double(void);
    void safeGetString(char arr[], int limit)

    char arr[255];
    double x,y,ans;

    printf("Enter a number: ");
    safeGetString(arr[255],255);
    my_sine(mod_two_pi(get_double()));
    printf("The sine is %f \n", ans);

    return 0;
}

/*
int_power should compute x^e, where x is a double and e is an integer.
*/
double int_power(double x, int e)
{
    int i = 0;
    double ans = 1;
    while(i <= e)
    {
        ans = ans*x;
        i++;
    }

    return ans;
}

/*
my_factorial will find the f开发者_高级运维actorial of n
*/
int my_factorial(int n)
{
    int i = n;
    int ans = 1;

    while(i > 0)
    {
        ans = ans*i;
        i = i-1;
    }

    return ans;
}

/*
my_sine_taylor computes the approxmiation
of sin(x) using the taylor series up through x^11/11!
*/
double my_sine_taylor(double x)
{
    return x - int_power(x,3)/my_factorial(3) + int_power(x,5)/my_factorial(5) - 
    int_power(x,7)/my_factorial(7) + int_power(x,9)/my_factorial(9) - 
    int_power(x,11)/my_factorial(11);
}

/*
my_sine(x) should return a very good approximation of sin(x).
It should first reduce x mod 2pi and then map the result into the
upper right quadrant (where the taylor approximation is quite accurate).
Finally, it should use my_sine_taylor to compute the answer.
*/

double my_sine(double x)
{
    double ans;

    if (x >= 0 && x <= PI/2){
        ans = my_sine_taylor(x);
    } else if (x > PI/2 && x <= PI){
        x=PI-x;
        ans = my_sine_taylor(x);
    } else if (x > PI && x <= 3*(PI/2)){
        x = x-PI;
        ans = -(my_sine_taylor(x));
    } else {
        x=2*PI-x;
        ans = -(my_sine_taylor(x));
    }
}

/*
mod_two_pi(x) should return the remainder when x
is divided by 2*pi.  This reduces values like
17pi/2 down to pi/2
*/
double mod_two_pi(double x)
{
    int y;
    y = floor(x/(2*PI));
    x = x - 2*PI*y;
    return x;
}

/*
get_double and safeGetString are used to get floating point
input from the user
*/
double get_double(void)
{
    double x;
    char arr[255];
    x=atof(arr);
}

void safeGetString(char arr[], int limit)
{
    int c, i;
    i = 0;

    c = getchar();
    while (c != '\n'){
        if (i < limit -1){
            arr[i] = c;
            i++;
        }
        c = getchar();
    }
    arr[i] = '\0';
}

---

oh my... where to begin?

Let's see...

---

You have this function:

double get_double(void)
{

    double x;

    char arr[255];

    x=atof(arr);
}

Which you call like this:

my_sine(mod_two_pi(get_double()));

So you're not sending it anything, but you're expecting to get some meaningful value. Basically, arr[255] is not initialized, so it holds garbage. You're taking this garbage and converting it to a float with atof, but that doesn't do anything.

If I had to guess, I'd say that this is what's really breaking your program. The rest of what I wrote below is just commentary.

---

For some reason, you're declaring all of these functions inside your main. I don't think this should break anything, but it sure is bad coding style.

---

my_sine_taylor calculates using a 6-element taylor approximation of the sine. Are you sure you need that accuracy? 11! is pretty large, and certain numbers to the 11th power can also be pretty large. You may be introducing unnecessary rounding or overflow errors with this.