使用系列时提高精度

Question

我被分配了一项任务来研究黎曼猜想的变体。我在下面创建了以下工作正常，但我意识到通过整数除法我达到了无法再运行测试结果的程度（大约 106 运行s）。我不确定是否还有其他原因可能导致我的程序在大约 106 次迭代后停止运行ning。有什么方法可以改进此代码，以便我可以运行更多测试结果吗？

#include <cstdlib>
#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;

int omegaN(int n){
    int omega[100] = {};
    int sum = 0;
    for (int i = 1; i <= n; i++){
        if ((n%i) == 0 ){
            omega[i] = i;
        }
        sum += (omega[i]);
    }
    cout << "\nSum of omega: " << sum << endl;
    return sum;
}

double Hn (int n){
    double sum = 0;
    double h_n;
    double whatBraunWants = 0;
    for (int i = 1.0; i <= n; i++){
        h_n = 1.0/i;
        sum += h_n;
    }
    cout << "Sum of Hn: " << sum << endl;
    whatBraunWants = sum + log(sum) * exp(sum);
    cout << "What Hn plus natural log stuff equals: " << whatBraunWants << endl;
    return whatBraunWants;
}

int main(int argc, char** argv) {
    for (int i = 1; i <= 100; i++){
        cout << "\nUsing n = " << i;
        if (omegaN(i) <= Hn(i)){
            cout << "Good for when n = " << i << endl;
        }
        else{
            cout << "No good when n = " << i << endl;
        }
    }
    return 0;
}

Answer 1

好的，这有点棘手。在行

int omega[100] = {};

在omegaN(int n)中，你将数组omega的大小固定为100。但是，当omegaN的输入参数[=18时，你执行了越界访问=].你最终覆盖了一些你不应该覆盖的内存（未定义的行为），所以所有的地狱休息都会丢失。

只需在堆栈上分配更多，例如int omega[1024];，或者更好的是，使用动态分配

int* omega = new int[n]; // now we know for sure we have enough storage space

别忘了

delete[] omega;

在 return-ing 来自 omegaN 之前。

或者，更好的是，使用来自 <memory> (C++11/14) 的智能指针并替换

int omega[100];

与

std::unique_ptr<int[]> omega(new int[n]{}); // or use std::make_unique in C++14

std::unique_ptr 析构函数将负责释放内存。

PS：您也可以使用 std::shared_ptr，但是与数组一起使用有点棘手，因为不幸的是没有 T[] 的特化，并且您必须提供自定义删除器。

PPS：对于循环条件，我还将 i <= n 替换为 i < n，因为前者很容易访问 [=48= 的最后一个元素之后].

使用系列时提高精度

Improve precision when working with series

c++

precision