带停止条件的欧拉数

Question

原始过时代码：编写一个计算Euler'；之前的s编号

我的算法课程教授给了我以下作业：

编写一个C/C++程序，以给定的精度eps>0提示：数字e=1+1/1+1/2！+…+1/n！+…=2.7172…可以计算为序列x_0，x_1，x_2，…的元素之和。。。，其中x_0=1，x_1=1+1/1！，x_2=1+1/1+1/2。。。，只要条件|x_(i+1(-x_i|>=eps有效。

正如他进一步解释的那样，eps是算法的精度。例如，精度可以是1/100|x_(i+1(-x_i|=(x_(i+1(-x-i(的绝对值

目前，我的程序看起来如下：

#include<iostream>
#include<cstdlib>
#include<math.h>
// Euler's number
using namespace std;
double factorial(double n)
{
double result = 1;
for(double i = 1; i <= n; i++)
{
result = result*i;
}
return result;
}
int main()
{
long double euler = 2;
long double counter = 2;
long double epsilon = 1.0/1000;
long double moduloDifference;
do
{
euler+=  1 / factorial(counter);
counter++;
moduloDifference = (euler + 1 / factorial(counter+1) - euler);
} while(moduloDifference >= epsilon);
printf("%.35Lf ", euler );
return 0;
}

问题：

1. 我的epsilon值似乎无法正常工作。它应该控制精度。例如，当我希望精度为5位时，我将其初始化为1.0/1000，并在8位之后(.7180(被截断之前输出3位数字
2. 当我使用长双数据类型，并且epsilon=1/10000时，我的epsilon得到值0，并且我的程序无限运行。然而，如果将数据类型从长双精度更改为双精度，则会起作用。为什么使用长双数据类型时epsilon变为0
3. 如何优化求欧拉数的算法？我知道，我可以去掉这个函数并快速计算欧拉值，但每次尝试这样做后，我都会收到其他错误

Answer 1

以这种方式计算欧拉常数的一个问题非常简单：你从一些相当大的数字开始，但由于每个项的分母都是N！，每个连续项的添加量迅速缩小。使用天真的求和，你很快就会达到一个点，你所加的值足够小，不再影响和。

在欧拉常数的特定情况下，由于数字不断减少，我们可以更好地处理它们的一种方法是计算和存储所有项，然后按相反的顺序将它们相加。

另一种更普遍的可能性是使用Kahan的求和算法。这会在求和时跟踪运行错误，并在添加每个连续项时将当前错误考虑在内。

例如，我重写了您的代码，使用Kahan求和来计算(大约(典型(80位(long double:的精度极限

#include<iostream>
#include<cstdlib>
#include<math.h>
#include <vector>
#include <iomanip>
#include <limits>
// Euler's number
using namespace std;
long double factorial(long double n)
{
long double result = 1.0L;
for(int i = 1; i <= n; i++)
{
result = result*i;
}
return result;
}
template <class InIt>
typename std::iterator_traits<InIt>::value_type accumulate(InIt begin, InIt end) {
typedef typename std::iterator_traits<InIt>::value_type real;
real sum = real();
real running_error = real();
for ( ; begin != end; ++begin) {
real difference = *begin - running_error;
real temp = sum + difference;
running_error = (temp - sum) - difference;
sum = temp;
}
return sum;
}
int main()
{  
std::vector<long double> terms;
long double epsilon = 1e-19;
long double i = 0;
double term;

for (int i=0; (term=1.0L/factorial(i)) >= epsilon; i++)
terms.push_back(term);
int width = std::numeric_limits<long double>::digits10;
std::cout << std::setw(width) << std::setprecision(width) << accumulate(terms.begin(), terms.end()) << "n";
}

结果：2.71828182845904522

公平地说，我实际上应该补充一点，我没有使用天真的求和来检查您的代码发生了什么——您看到的问题可能来自其他来源。另一方面，这确实非常适合卡汉求和至少有合理机会改善结果的情况。

Answer 2

#include<iostream>
#include<cmath>
#include<iomanip>
#define EPSILON  1.0/10000000
#define AMOUNT  6
using namespace std;
int main() {

long double e = 2.0, e0;
long double factorial = 1;
int counter = 2;
long double moduloDifference;
do {
e0 = e;
factorial *= counter++;
e += 1.0 / factorial;
moduloDifference = fabs(e - e0);
} while (moduloDifference >= EPSILON);
cout << "Wynik:" << endl;
cout << setprecision(AMOUNT) << e << endl;
return 0;
}

这是一个优化版本，没有单独的函数来计算阶乘。

问题1：我仍然不确定EPSILON是如何管理精度的。

问题2：我不明白长双和双的真正区别。关于我的代码，为什么长双精度需要小数点(1.0/someNumber(，而双精度不需要(1/someNumber(