C++ 如何计算精度为e=0.0001的序列e^（-x）之和？

所以我可以计算序列的和，而不需要精确的E

    int t=1, x, k;
    float sum, a, result, factorial=1, E=0.0001;
    for(k=0;k<=(n);k++){
                while(t<=n){
                        factorial*=t;
                        t++;
                }
                sum=(pow(-x,k))/factorial;
                sum+=sum;
                //while(fabs(sum-???)<E){
                //        result=sum;
                //}
    }

int t=1，x，k；
浮点数和，a，结果，阶乘=1，E=0.0001；
对于（k=0；k首先，请注意您应用的幂公式：根据，您应该添加术语
pow（-x，k）/（k！）
，而不是
pow（-x，k）/（n！）

这将导致代码的一个小优化：当
k！=k*（k-1）！
我们可以避免内部
while
循环和大量无用的乘法

顺便说一句，在构建和的方式中也有一个错误：您总是删除以前的结果，然后在当前项中添加第二次

纠正后，您只需处理一个附加变量：

double myexpo(double x, int n=100) {
    int k;
    double sum = 1.0, pvsum, factorial = 1.0, E = 0.0001;
    for (k = 1; k <= (n); k++){  // start with 1
        pvsum = sum;
        factorial *= k;            // don't calculate factorial for 0. 
        sum += (pow(-x, k)) / factorial;

        if (k > 1 && fabs(sum - pvsum) < E) {  // check if diff is small enough
            cout << k << " iterations" << endl; 
            break;     // interupt the for loop if it's precise enough
        }
    }
    return sum;   // at the end of the loop sum is the best approximation
}

double myexpo（double x，int n=100）{
int k；
双和=1.0，pvsum，阶乘=1.0，E=0.0001；
对于（k=1；kx；
当术语的绝对值小于您期望的准确度时，请检查

double sum = 0, x = 1, k = 0, E = 0.0001, fact = 1;
while(true){
    double term = pow(-x, k) / fact;
    if(fabs(term) < E)
        break;
    sum += term;
    fact *= (++k);
}
printf("e^(-x) = %.4f", sum);

double sum=0，x=1，k=0，E=0.0001，fact=1；
while（true）{
双项=功率（-x，k）/事实；
if（晶圆厂（期限）
这是e^（-x）的泰勒级数吗？如果是这样，你写错了。我认为你得到的不会收敛


e^（-x）是1+（-x）+（-x）^2/2！+（-x）^3/3！+

double calculate_power_of_e(double xx, double accuracy) {
    double sum(1.0);
    double term(1.0);
    for (long kk=1; true; ++kk) {
        term *= (-xx) / kk;
        sum += term;
        if (fabs(term) < accuracy)
            break;
    }

    return sum;
}

printf("e^(-x)" = %.4f\n", calculate_power_of_e(5.0, .0001));

双计算e的功率（双xx，双精度）{
双和（1.0）；
双项（1.0）；
for（长kk=1；真；++kk）{
术语*=（-xx）/kk；
总和+=期限；
if（晶圆厂（术语）<精度）
打破
}
回报金额；
}
printf（“e^（-x）”=%.4f\n，计算e的幂（5.0.0001））；
当术语与1.0相比不重要时，停止循环

通过使用递归，并且
|x |
不是太大，最小的项首先求和

e(x) = 1 + x/1! + x*x/2! + x*x*x/3! + ...

double my_exp_term(double x, double term, unsigned n) {
  if (term + 1.0 == 1.0) return term;
  n++;
  return term + my_exp_term(x, term*x/n, n);
}

double my_exp(double x) {
  return 1.0 + my_exp_term(x, x, 1);
}

double y = my_exp(-1);

oops.忘了更新psum。只需在循环的底部添加一个psum=sum。因为您有
sum+=term
，所以需要检查的是
fabs（term）
。这允许您在（0
。如果你从
1
开始
kk
和
sum
，那么你也不需要先
if（0
。我帮你修好了，如果需要，可以随意回滚编辑。看起来不错，谢谢。泰勒级数收敛得很慢。
e(x) = 1 + x/1! + x*x/2! + x*x*x/3! + ...

double my_exp_term(double x, double term, unsigned n) {
  if (term + 1.0 == 1.0) return term;
  n++;
  return term + my_exp_term(x, term*x/n, n);
}

double my_exp(double x) {
  return 1.0 + my_exp_term(x, x, 1);
}

double y = my_exp(-1);