Question

我试图编写一个程序来计算exp（-x）和exp（x）的Taylor系列，最多200次迭代，对于大x。（EXP（X）= 1 + X + X ^ 2/2 + ...）。

我的程序非常简单，看起来应该可以完美运行。然而，它对于exp（-x）来说是不同的，但是对于exp（+ x）来说收敛得很好。到目前为止，这是我的代码：

long double x = 100.0, sum = 1.0, last = 1.0;

for(int i = 1; i < 200; i++) {
        last *= x / i;    //multiply the last term in the series from the previous term by x/n
        sum += last; //add this new last term to the sum
    }
cout << "exp(+x) = " << sum << endl;

x = -100.0; //redo but now letting x<0
sum = 1.0;
last = 1.0;

for(int i = 1; i < 200; i++) {
            last *= x / i;
            sum += last;
        }
    cout << "exp(-x) = " << sum << endl;

当我运行它时，我得到以下输出：

exp(+x) = 2.68811691354e+43 
exp(-x) = -8.42078025179e+24

当实际值为：

exp(+x) = 2.68811714182e+43 
exp(-x) = 3.72007597602e-44

正如您所看到的，它对于正计算很有效，但不是负面的。有没有人有任何关于为什么舍入错误可能会因为在每个其他术语中添加否定而错误的想法？另外，我有什么办法可以解决这个问题吗？

提前致谢!!

Answer 1

产生舍入误差的最常见操作之一是减去几乎相等的数字。当计算exp（-100）时，高阶项几乎相等，因此舍入误差可以快速累积。事实是，后来的迭代在long double类型的范围之外运行，这更加复杂。根据{{3}}，长双的范围是从1.7E +/- 308（15位），而200！是7.89 x 10 ^ 374。

如果您只是在寻找exp实现，microsoft有一个实现。

Answer 2

我不认为这实际上与浮点近似误差有关，我认为还有另一个更重要的错误来源。

正如你自己所说，你的方法非常简单。您正在x=0对此函数进行泰勒级数近似，然后在x=-100进行评估。

您实际上期望这种方法有多准确？为什么？

在较高级别，您应该只希望您的方法在x=0附近的狭窄区域内准确。泰勒的近似定理告诉你，例如如果您在N周围使用x=0系列术语，那么您的近似值至少会精确到O(|x|)^(N+1)。因此，如果您使用200个术语，则应该准确在10^(-60)范围内的[-0.5, 0.5]左右。但是在x=100泰勒的定理只给你一个非常可怕的界限。

从概念上讲，您知道e^{-x}趋于零，因为x变为负无穷大。但是你的近似函数是一个固定度的多项式，并且任何非常数多项式渐近地倾向于加上无穷大或负无穷大。因此，如果考虑x的整个可能值范围，相对误差必须是无限的。

所以简而言之，我认为你应该重新思考你的方法。您可以考虑的一件事是，仅使用泰勒级数方法来x满足-0.5f <= x <= 0.5f的值。对于任何大于x的{{1}}，您可以尝试将0.5f除以2并递归调用该函数，然后对结果进行平方。或类似的东西。

为了获得最佳效果，您应该使用既定方法。

编辑：

我决定写一些代码，看看我的想法实际上有多好。它似乎与x到x = -10000范围内的C库实现完全匹配，至少与我显示的精度一样多。：）

另请注意，即使x = 10000大于100的值，我的方法也是准确的，其中泰勒级数方法实际上也会在正端失去准确性。

输出：

#include <cmath>
#include <iostream>

long double taylor_series(long double x)
{
    long double sum = 1.0, last = 1.0;

    for(int i = 1; i < 200; i++) {
            last *= x / i;    //multiply the last term in the series from the previous term by x/n
            sum += last; //add this new last term to the sum
    }

    return sum;
}

long double hybrid(long double x)
{
    long double temp;
    if (-0.5 <= x && x <= 0.5) {
        return taylor_series(x);
    } else {
        temp = hybrid(x / 2);
        return (temp * temp);
    }
}

long double true_value(long double x) {
    return expl(x);
}

void output_samples(long double x) {
    std::cout << "x = " << x << std::endl;
    std::cout << "\ttaylor series = " << taylor_series(x) << std::endl;
    std::cout << "\thybrid method = " << hybrid(x) << std::endl;
    std::cout << "\tlibrary = " << true_value(x) << std::endl;
}

int main() {
    output_samples(-10000);
    output_samples(-1000);
    output_samples(-100);
    output_samples(-10);
    output_samples(-1);
    output_samples(-0.1);
    output_samples(0);
    output_samples(0.1);
    output_samples(1);
    output_samples(10);
    output_samples(100);
    output_samples(1000);
    output_samples(10000);
}

编辑：

对谁感兴趣：

在评论中提出了一些问题，浮点错误在原始程序中有多重要。我最初的假设是它们可以忽略不计 - 我做了一个测试，看看它是否真实。事实证明这不是真的，并且存在明显的浮点错误，但即使没有浮点错误，仅仅由泰勒系列引入了重大错误。泰勒系列在$ ./main x = -10000 taylor series = -2.48647e+423 hybrid method = 1.13548e-4343 library = 1.13548e-4343 x = -1000 taylor series = -2.11476e+224 hybrid method = 5.07596e-435 library = 5.07596e-435 x = -100 taylor series = -8.49406e+24 hybrid method = 3.72008e-44 library = 3.72008e-44 x = -10 taylor series = 4.53999e-05 hybrid method = 4.53999e-05 library = 4.53999e-05 x = -1 taylor series = 0.367879 hybrid method = 0.367879 library = 0.367879 x = -0.1 taylor series = 0.904837 hybrid method = 0.904837 library = 0.904837 x = 0 taylor series = 1 hybrid method = 1 library = 1 x = 0.1 taylor series = 1.10517 hybrid method = 1.10517 library = 1.10517 x = 1 taylor series = 2.71828 hybrid method = 2.71828 library = 2.71828 x = 10 taylor series = 22026.5 hybrid method = 22026.5 library = 22026.5 x = 100 taylor series = 2.68812e+43 hybrid method = 2.68812e+43 library = 2.68812e+43 x = 1000 taylor series = 3.16501e+224 hybrid method = 1.97007e+434 library = 1.97007e+434 x = 10000 taylor series = 2.58744e+423 hybrid method = 8.80682e+4342 library = 8.80682e+4342 200个词的真实价值似乎接近x=-100，而不是-10^{24}。我使用10^{-44}检查了这一点，boost::multiprecision::cpp_rational是一个基于任意精度整数类型的任意精度有理类型。

输出：

x = -100
    taylor series (double) = -8.49406e+24
                (rational) = -18893676108550916857809762858135399218622904499152741157985438973568808515840901824148153378967545615159911801257288730703818783811465589393308637433853828075746484162303774416145637877964256819225743503057927703756503421797985867950089388433370741907279634245166982027749118060939789786116368342096247737/2232616279628214542925453719111453368125414939204152540389632950466163724817295723266374721466940218188641069650613086131881282494641669993119717482562506576264729344137595063634080983904636687834775755173984034571100264999493261311453647876869630211032375288916556801211263293563
                           = -8.46257e+24
    library                = 3.72008e-44
x = 100
    taylor series (double) = 2.68812e+43
                (rational) = 36451035284924577938246208798747009164319474757880246359883694555113407009453436064573518999387789077985197279221655719227002367495061633272603038249747260895707250896595889294145309676586627989388740458641362406969609459453916777341749316070359589697827702813520519796940239276744754778199440304584107317957027129587503199/1356006206645357299077422810994072904566969809700681604285727988319939931024001696953196916719184549697395496290863162742676361760549235149195411231740418104602504325580502523311497039304043141691060121240640609954226541318710631103275528465092597490136227936213123455950399178299
                           = 2.68812e+43
    library                = 2.68812e+43

代码：

#include <cmath>
#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>

typedef unsigned int uint;
typedef boost::multiprecision::cpp_rational rational;

// Taylor series of exp

template <typename T>
T taylor_series(const T x) {
    T sum = 1, last = 1;

    for (uint i = 1; i < 200; i++) {
        last = last * (x / i);
        sum = sum + last;
    }
    return sum;
}

void sample(const int x) {
    std::cout << "x = " << x << std::endl;
    long double e1 = taylor_series(static_cast<long double>(x));
    std::cout << "\ttaylor series (double) = " << e1 << std::endl;
    rational e2 = taylor_series(static_cast<rational>(x));
    std::cout << "\t            (rational) = " << e2 << std::endl;
    std::cout << "\t                       = " << static_cast<long double>(e2) << std::endl;
    std::cout << "\tlibrary                = " << expl(static_cast<long double>(x)) << std::endl;
}

int main() {
    sample(-100);
    sample(100);
}

Answer 3

使用泰勒多项式可能不是一个好主意;有关使用切比雪夫多项式进行函数逼近的精彩文章，请参阅http://www.embeddedrelated.com/showarticle/152.php。

rickandross在这种情况下指出了错误的来源，即exp（-100）的泰勒展开涉及大值的差异。

泰勒尝试有一个简单的修改，可以为我尝试的几个测试用例得到合理的答案，即使用exp（-x）= 1 / exp（x）这一事实。这个计划：

#include <iostream>
#include <cmath>

double texp(double x)
{
  double last=1.0;
  double sum=1.0;
  if(x<0)
    return 1/texp(-x);

  for(int i = 1; i < 200; i++) {
    last *= x / i;
    sum += last;
  }

  return sum;
}

void test_texp(double x)
{
  double te=texp(x);
  double e=std::exp(x);
  double err=te-e;
  double rerr=(te-e)/e;
  std::cout << "x=" << x 
            << "\ttexp(x)=" << te 
            << "\texp(x)=" << e 
            << "\terr=" << err
            << "\trerr=" << rerr
            << "\n";
}

int main()
{
  test_texp(0);
  test_texp(1);
  test_texp(-1);
  test_texp(100);
  test_texp(-100);
}

给出了这个输出（注意双精度约为2e-16）：

x=0 texp(x)=1   exp(x)=1    err=0   rerr=0
x=1 texp(x)=2.71828 exp(x)=2.71828  err=4.44089e-16 rerr=1.63371e-16
x=-1    texp(x)=0.367879    exp(x)=0.367879 err=-5.55112e-17    rerr=-1.50895e-16
x=100   texp(x)=2.68812e+43 exp(x)=2.68812e+43  err=1.48553e+28 rerr=5.52628e-16
x=-100  texp(x)=3.72008e-44 exp(x)=3.72008e-44  err=-2.48921e-59    rerr=-6.69128e-16

泰勒级数exp（-x）和exp（+ x）之间的差异

3 个答案:

泰勒级数exp（-x）和exp（+ x）​​之间的差异

3 个答案:

泰勒级数exp（-x）和exp（+ x）之间的差异