用 C 中的泰勒级数逼近 Sine(x) 并有很多问题

Question

I'm trying to approximate sine(x) in C using a Taylor series and Stirling's approximation for factorials but I'm getting really weird answers for n<5 and -0 for any n=>5. I literally just started learning yesterday so i'd appreciate it if some more experienced programmers could take a look at it and tell me what's wrong

Taylor Series of Sine

Stirling's approximation of factorials

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

int main(){

float x,n,s,i,e,p,f,r;
f=M_PI;
e=2.7182818;
s=0;

printf("What value of sine do you want to apporximate?");
    scanf("%f", &x);
printf("With what level of precision do you want to calculate it?");
    scanf("%f", &n);
for(i=0;i<=n; ++i);{
    r=((2*i)+1);
    p=(sqrt(2*r*f)*(pow((r/e),r)));
    s=s+(((pow((-1),i))*(pow(x,((2*i)+1))))/p);
}
printf("the value of sine at %f is %f",x,s);
}

Answer 1

This line

    for(i = 0; i <= n; ++i);{

has an extra semicolon. You're executing an empty loop.

Answer 2

BAsed on your formulat this is the correct code but it generate wrong output so you need to check again your formulat:

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

int main(){

double x,n,s,i,e,p,f;
f=M_PI;
e=2.7182818;
s=0;
int sign=0;// Adding this type to toggle the sign 

printf("What value of sine do you want to apporximate?");
    scanf("%lf", &x);// conversion specifier must be %lf for floating number
printf("With what level of precision do you want to calculate it?");
    scanf("%lf", &n);
for(i=1;i<=n; i=i+2){ // Correcting the for loop
    p=sqrt(2*i*f)*pow((i/e),i); 
    s=s+(pow(-1,sign++)*pow(x,i))/p;
}
printf("the value of sine at %f is %f",x,s);
}

Answer 3

this is easier bro

#include <iostream>
#include <cmath>
using namespace std;
double factorial(int X)
{
    double factorial = 1;
    for(int i=1; i<=X; i++)
    {
        factorial = factorial *i;
    }
    return factorial;
}
double Mysin(double x,double result)
{
        for(int i = 0;i<20;i++)
    {
        result+=pow((-1),i)*pow(x,((2*i)+1))/factorial((2*i)+1);
    }
    return result;
}
double Mycos(double x,double result)
{
    for(int i = 0;i<20;i++)
    {
        result+=pow(-1,i)*pow(x,2*i)/factorial(2*i);
    }
    return result;
}
double Mytan(double sine,double cosine)
{
    return sine/cosine;
}
double deg_to_rad(double x)
{
    double const pi = 3.14159265359;
    return x*pi/180;
}
int main()
{
    double x,result=0;
    cin>>x;
    cout<<"My sin: "<<Mysin(deg_to_rad(x),result)<<endl;
    cout<<"My cosin: "<<Mycos(deg_to_rad(x),result)<<endl;
    cout<<"My tan: "<<Mytan(Mysin(deg_to_rad(x),result),Mycos(deg_to_rad(x),result))<<endl;
    return 0;
}

Answer 4

Check your factorial function: it returns a double, but you will see that factorial of numbers like 8 or 10 are beyond the range of a double variable. Use long as returning type...

Answer 5

As the sin() is a periodic function, I should never go further than one period to calculate it. This simplifies too much mathematics, as you never need to calculate great factorial numbers. Indeed you even don't need to calculate the factorial for each term in the series, as the coefficients can be derived one from the last, by just dividing the previous coefficient by (n-1) and n . if your input is bounded to one period (well, you don't need to use a fixed period of M_PI , you can go let's say to a maximum value of 3.5 and reduce your answers for values greater by just reducing by the modulus of the division by M_PI .

Once said this, we can bind your maximum error, as for the greatest input of 3.5 we will have 3.5^n/n! as the last term of our approximation, with is bounded for some n to be less than some maximum error which fixes the number of terms we'll need to calculate.

Instead of trying to be precise with the number of terms needed to calculate, I'll try to do some guesses, from deriving an algorithm and showing actual values (for example, for the maximum input value of 3.2 )

These are the values of the term at position n for input of 3.2 and

   n  | term at position n for input `3.2`
======+=================
   8  |  0.27269634
  12  |  0.00240693
  16  |  0.00000578
  18  |  0.00000019
  20  |  0.00000001
  21  |  7.9E-10

So we can stop on calculating just 20 terms of the series. This is true for the exp() function which has all terms added and is a simple function. For the sin() or cos() you can guess that a better error estimate if you consider that both have the same terms of the exp() function, (well the first has only the odd terms, the second has only the even terms)

 (x^n)/(n!) - (x^(n+2))/((n+2)!) = (n!*x^n*(1 - x^2/((n+1)*(n+2))))/n!

that for n > 3.2 means each term is

< x^n/n!

so we can apply the same criterion as for the exponential.

This to say that we can stop at some point... if we continue our table we'll see that at, for example n > 30 the overall accumulated term is less than 5.3E-18 so we can stop there (for a double number, at least).

#include <stdio.h>
#include <math.h> /* for the system sin() function */

double MySin(double x) /* x must be in the range [0..3.2] */
{
    int i;
    const int n = 30;
    double t = x, acum = x; /* first term, x/1! */
    x *= x; /* square the argument so we get x^2 in variable x */
    for (i = 3; i < n; i += 2) {
             t = -t * x / i / (i-1); /* mutiply by -1, x^2 and divide by i and (i-1) */
             acum += t; /* and add it to the accum */
    }
    return acum;
}

int main()
{
    double arg;
    for(;;) {
            if (scanf("%lg", &arg) != 1)
                    break;
            printf("MySin(%lg) = %lg; sin(%lg) = %lg\n",
                    arg, MySin(arg), arg, sin(arg));
    }
}

If you take advantage from the symmetries that the sin function has, you can reduce your domain to M_PI/4 which is less than one, and you can stop even at term of power 18 to get around 17 significative digits (for a double ) which makes your sin faster.

Finally, we can get a valid for all real domain sin2() function by:

double sin2(double x)
{
    bool neg = false;
    int ip = x / 2.0 / M_PI;
    x -= 2.0 * M_PI * ip;                    /* reduce to first period [-2PI..2PI] */
    if (x < 0.0) x += 2.0*M_PI;              /* reduce to first period [0..2PI] */
    if (x > M_PI) { x -= M_PI; neg = true; } /* ... first period negative [ 0..PI ] */
    if (x > M_PI/2.0) x = M_PI - x;          /* reflection [0..PI/2] */
    return neg ? MySin(-x) : MySin(x);
}