输出是 nan 而它不应该是

Question

我需要计算以下内容：

S= 1- x^2 / 2！ + x^4 / 4！ - x^6 / 6！ + ... + (-1)^n * x^2n / (2n)！

其中 n 介于 1 到 100 之间，x 是双精度数。

我有以下代码：

unsigned int factorial (unsigned int n)
{
    if (n == 0)
        return 1;
    return n * factorial(n - 1);
}

double exFive(int n, double x)
{
    double s = 1;

    for (int i = 1; i <= n; ++i)
    {
        int j = 2 * i; 
        s = s + pow(-1, i) * pow(x, 2*i) / factorial(j); //problem is here I guess
    }

    return s;
}

void fiveIO()
{
    int n = 1;
    double x;
   
    cout << "Input n: ";
    cin >> n;
    while ((n < 1) || (n > 100))
    {
        cout << "Wrong number, input again: ";
        cin >> n;
    } 

    cout << "Input: ";
    cin >> x;

    cout << "Result is " << fixed << setprecision(2) << exFive(n, x);
}

它可以工作，但是结果是 nan，其中 n 高于 ~15.. 但我不知道为什么。 我猜是 FiveX 功能。

所以，例如，n = 3, x = 5 输出 -7.16（这是正确的），但 n = 50, x = 5 输出“nan”.. 是因为输出的数字太大了吗？但是那我该怎么做呢？

Answer 1

避免int 在factorial(j) Typical 32-bit int can only hold result of factorial(12) 中溢出（未定义的行为 (UB)）。

通过根据之前的值计算term 来改进循环计算。

//for (int i = 1; i <= n; ++i) {
//    int j = 2 * i; 
//    s = s + pow(-1, i) * pow(x, 2*i) / factorial(j); //problem is here I guess
//}

// Something like
double xx = x*x;
double term = 1.0;
for (int i = 1; i <= n; ++i) {
    int j = 2 * i; 
    term *= -xx / ((j-1)*j);
    s += term;
}

---

更高级的方法是反向计算总和以最小化计算错误，但很大程度上取决于x 的允许范围，这不受 OP 的限制。

Answer 2

对于公式：

S= 1- x^2 / 2！ + x^4 / 4！ - x^6 / 6！ + ... + (-1)^n * x^2n / (2n)！

我提交的这个实现的规模略好一些，因为它避免了一次将所有内容相乘。

double exFive(int n, double x)
{
    double s = 1;

    bool subtract = true;

    for (int i = 1; i <= n; i++)
    {
        double inner = 1;
        int n2 = i * 2;
        for (int j = 1; j <= n2; j++)
        {
            inner *= (x / j);
        }

        if (subtract)
        {
            s = s - inner;
        }
        else
        {
            subtract = s + inner;
        }
        subtract = !subtract;
    }
    return s;
}

示例运行：

Input n: 100
Input: 94
Result is -4417.00

上面的实现，当它需要计算时说(x^n)/(n!)。而不是计算

T  = (x*x*x*x....*x*x*x) / (1*2*3*4*5*6*....*(N-1)*N)`

在上面的表达式中，当尝试使用pow 或factorial 函数进行计算时，分子和分母都会溢出。因此，它会将其计算为：

T = (x/1) * (x/2) * (x/3) * (x/4) * (x/5) * (x/6)

这避免了使用阶乘和 pow 函数。而且由于外循环的每次迭代都是交替进行减法或加法运算，溢出的机会仍然较小。