1

I'm trying to calculate the the taylor series of cos(x) with error at most 10^-3 and for all x ∈ [-pi/4, pi/4], that means my error needs to be less than 0.001. I can modify the x +=in the for loop to have different result. I tried several numbers but it never turns to an error less than 0.001.

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

float cosine(float x, int j)
{
    float val = 1;
    for (int k = j - 1; k >= 0; --k)
        val = 1 - x*x/(2*k+2)/(2*k+1)*val;
    return val;
}

int main( void )
{
   for( double x = 0; x <= PI/4; x += 0.9999 )
   {

       if(cosine(x, 2) <= 0.001)
       {
           printf("cos(x) : %10g    %10g    %10g\n", x, cos(x), cosine(x, 2));
       }
       printf("cos(x) : %10g    %10g    %10g\n", x, cos(x), cosine(x, 2));
    }

    return 0;
}

I'm also doing this for e^x too. For this part, x must in [-2,2] . 

float exponential(int n, float x)
{
    float sum = 1.0f; // initialize sum of series

    for (int i = n - 1; i > 0; --i )
        sum = 1 + x * sum / i;

    return sum;
}

int main( void )
{
    // change the number of x in for loop so you can have different range
    for( float x = -2.0f; x <= 2.0f; x += 1.587 )
    {
        // change the frist parameter to have different n value
        if(exponential(5, x) <= 0.001)
        {
            printf("e^x = %f\n", exponential(5, x));
        }
    printf("e^x = %f\n", exponential(5, x));
    }

    return 0;
}

But whenever I changed the number of terms in the for loop, it always have an error that is greater than 1. How am I suppose to change it to have errors less than 10^-3?

Thanks!

4

2 回答 2

0

我的理解是，为了提高精度，您需要考虑泰勒级数中的更多项。例如，考虑当您尝试通过泰勒级数计算 e(1) 时会发生什么。

$e(x) = \sum\limits_{n=0}^{\infty} frac{x^n}{n!}$

我们可以考虑 e(1) 展开式中的前几项：

n             value of nth term           sum
0        x^0/0! = 1                   1
1        x^1/1! = 1                   2
2        x^2/2! = 0.5                 2.5
3        x^3/3! = 0.16667             2.66667
4        x^4/4! = 0.04167             2.70834

您应该注意到两件事，首先，随着我们添加更多项，我们越来越接近 e(1) 的确切值，而且连续和之间的差异也越来越小。

因此，e(x) 的实现可以写成：

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

typedef float (*term)(int, int);
float evalSum(int, int, int, term);
float expTerm(int, int);
int fact(int);
int mypow(int, int);
bool sgn(float);

const int maxTerm = 10;         // number of terms to evaluate in series
const float epsilon = 0.001;    // the accepted error

int main(void)
{
    // change these values to modify the range and increment 
    float   start = -2;
    float   end = 2;
    float   inc = 1;

    for(int x = start; x <= end; x += inc)
    {
        float value = 0;
        float prev = 0;

        for(int ndx = 0; ndx < maxTerm; ndx++)
        {
            value = evalSum(0, ndx, x, expTerm);

            float diff = fabs(value-prev);
            if((sgn(value) && sgn(prev)) && (diff < epsilon))
                 break;
            else
                 prev = value;
        }

        printf("the approximate value of exp(%d) is %f\n", x, value);
    }

    return 0;
}

我曾经猜测我们不需要在扩展中使用超过十个项来达到所需的精度，因此内部 for 循环是我们循环n[0,10] 范围内的值的地方。

此外，我们有几行专门用于检查我们是否达到所需的精度。首先我计算当前评价与上一次评价的差值的绝对值，取绝对差值。检查差值是否小于我们的 epsilon 值 (1E-3) 是提前退出循环的标准之一。由于计算 e(-1) 的值的一些波动，我还需要检查当前值和以前值的符号是否相同，这就是条件中的第一个子句正在做的事情。

float evalSum(int start, int end, int val, term fnct)
{
    float sum = 0;
    for(int n = start; n <= end; n++)
    {
        sum += fnct(n, val);
    }

   return sum;
}

这是我编写的一个效用函数，用于评估系列的前 n 项。 start是起始值（此代码始终为 0），并且end是结束值。最后一个参数是一个指向函数的指针，该函数表示如何计算给定项。在此代码中，fnct 可以是指向任何接受整数参数并返回浮点数的函数的指针。

float expTerm(int n, int x)
{
    return (float)mypow(x,n)/(float)fact(n);
}

埋藏在这个单行函数中的是大部分工作发生的地方。此函数表示 e(n) 的泰勒展开的封闭形式。仔细查看上面的内容，您应该能够看到我们正在为给定的 x 和 n 值计算 $\fract{x^n}{n!}$。作为提示，对于余弦部分，您需要创建一个函数来评估 cos 的泰勒展开中的项的闭项。这是由 $(-1)^n\fact{x^{2n}}{(2n)!}$ 给出的。 

int fact(int n)
{
    if(0 == n)
        return 1;             // by defination
    else if(1 == n)
        return 1;
    else
        return n*fact(n-1);
}

这只是阶乘函数的标准实现。这里没有什么特别可看的。

int mypow(int base, int exp)
{
    int result = 1;

    while(exp)
    {
        if(exp&1)              // b&1 quick check for odd power
        {
            result *= base;
        }

        exp >>=1;              // exp >>= 1 quick division by 2
        base *= base;
    }

    return result;
}

进行幂运算的自定义函数。我们当然可以使用 的版本<math.h>，但是因为我知道我们只会做整数幂，所以我们可以编写一个优化的版本。提示：在做余弦时，您可能需要使用 from 版本<math.h>来处理浮点基数。

bool sgn(float x)
{
    if(x < 0) return false;
    else return true;
}

一个非常简单的函数，用于确定浮点值的符号，返回 true 为正，否则返回 false。

这段代码是在我的 Ubuntu-14.04 上使用 gcc 版本 4.8.4 编译的：

******@crossbow:~/personal/projects$ gcc -std=c99 -pedantic -Wall series.c -o series
******@crossbow:~/personal/projects$ ./series
the approximate value of exp(-2) is 0.135097
the approximate value of exp(-1) is 0.367857
the approximate value of exp(0) is 1.000000
the approximate value of exp(1) is 2.718254
the approximate value of exp(2) is 7.388713

使用bc给出的预期值是：

******@crossbow:~$ bc -l
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
e(-2)
.13533528323661269189
e(-1)
.36787944117144232159
e(0)
1.00000000000000000000
e(1)
2.71828182845904523536
e(2)
7.38905609893065022723

如您所见，这些值完全在您要求的公差范围内。我把它作为一个练习来做余弦部分。

希望这会有所帮助，
-T

于 2015-12-10T16:34:22.940 回答
0

exp并且cos具有在实线上处处收敛的幂级数。对于任何有界区间，例如[-pi/4, pi/4]或[-2, 2]，幂级数不仅逐点收敛，而且一致地收敛到exp和cos。

逐点收敛意味着对于x该区域中的 any 和 any epsilon > 0，您可以选择一个足够大的值，N以便您从N泰勒级数的第一项获得的近似值epsilon在真实值范围内。然而，在逐点收敛的情况下，N对于一些 ' 可能很小，x而对于另一些可能很大，并且由于存在无限多个x'，因此可能没有一个有限N的可以容纳所有这些。对于某些功能，有时确实会发生这种情况。

均匀收敛意味着对于任何epsilon > 0，您都可以选择一个足够大的值，以使该区域中的 EVERYN的近似值都在范围内。这就是您正在寻找的近似值，并且您可以保证这就是您所拥有的那种收敛。epsilonx

原则上，您可以查看在任何有限域上一致收敛的证明之一exp，cos坐下来说“如果我们采用，以及要成为...的区域会怎样”，然后使用笔epsilon = .001计算一些有限界，然后N纸。然而，这些证明中的大多数将在某些步骤中使用一些不精确的估计，因此N您计算的值将大于必要的值——可能要大得多。将它实现为N一个变量会更简单，然后像在代码中那样使用 for 循环检查值，看看你必须使它有多大，以使错误比.001任何地方都小。

因此，我无法判断N您需要选择的正确值是多少，但数学可以保证，如果您继续尝试更大的值，最终您会找到一个有效的值。

于 2015-12-10T17:05:55.330 回答