相关疑难解决方法(0)

这是一段看似非常特殊的C++代码.出于某种奇怪的原因,奇迹般地对数据进行排序使得代码几乎快了六倍.

#include <algorithm>
#include <ctime>
#include <iostream>

int main()
{
    // Generate data
    const unsigned arraySize = 32768;
    int data[arraySize];

    for (unsigned c = 0; c < arraySize; ++c)
        data[c] = std::rand() % 256;

    // !!! With this, the next loop runs faster.
    std::sort(data, data + arraySize);

    // Test
    clock_t start = clock();
    long long sum = 0;

    for (unsigned i = 0; i < 100000; ++i)
    {
        // Primary loop
        for (unsigned c = 0; c < arraySize; ++c) …

我正在寻找获得π值的最快方法,作为个人挑战.更具体地说,我使用的方法不涉及使用#define常量M_PI,或者对数字进行硬编码.

下面的程序测试了我所知道的各种方式.从理论上讲,内联汇编版本是最快的选择,但显然不便于携带.我已将其作为基线与其他版本进行比较.在我的测试中,使用内置4 * atan(1)函数,在GCC 4.2上版本最快,因为它会自动将其折叠atan(1)为常量.根据-fno-builtin指定,atan2(0, -1)版本最快.

这是主要的测试程序(pitimes.c):

#include <math.h>
#include <stdio.h>
#include <time.h>

#define ITERS 10000000
#define TESTWITH(x) {                                                       \
    diff = 0.0;                                                             \
    time1 = clock();                                                        \
    for (i = 0; i < ITERS; ++i)                                             \
        diff += (x) - M_PI;                                                 \
    time2 = clock();                                                        \
    printf("%s\t=> %e, time => %f\n", #x, diff, diffclock(time2, time1));   \
}

static inline double
diffclock(clock_t time1, clock_t time0)
{ …

我开始学习CUDA,我认为计算pi的长数字将是一个很好的介绍性项目.

我已经实现了简单的蒙特卡罗方法,该方法很容易并行化.我只是让每个线程在单位正方形上随机生成点,计算单位圆内有多少点,并使用缩小操作计算结果.

但这当然不是计算常数的最快算法.以前,当我在单线程CPU上进行此练习时,我使用类似Machin的公式来进行计算,以便更快地收敛.对于那些感兴趣的人,这涉及将pi表示为反复数组的总和并使用泰勒级数来评估表达式.

这样一个公式的一个例子:

不幸的是,我发现将这种技术并行化到数千个GPU线程并不容易.问题是大多数操作只是在进行高精度数学运算,而不是对长数据向量进行浮点运算.

所以我想知道,在GPU上计算pi的任意长数字的最有效方法是什么？

我需要使用以下公式以预定义的精度计算PI:

所以我最终得到了这个解决方案.

private static double CalculatePIWithPrecision(int presicion)
{
    if (presicion == 0)
    {
        return PI_ZERO_PRECISION;
    }

    double sum = 0;

    double numberOfSumElements = Math.Pow(10, presicion + 2);

    for (double i = 1; i < numberOfSumElements; i++)
    {
        sum += 1 / (i * i);
    }

    double pi = Math.Sqrt(sum * 6);
    return pi;
}

所以这是正确的,但我遇到了效率问题.精度值为8或更高时,它非常慢.

是否有更好(更快!)的方法来使用该公式计算PI？

我被要求打印莱布尼茨公式的总和，直到该系列的第 n 项正确到小数点后 15 位。在微积分中，莱布尼茨公式的 ? 由下式给出：1 - 1/3 + 1/5 -1/7 + ... = ?/4

这是我的代码

#include<stdio.h>
#include<math.h>
int main()
{
    int n,i;
    long double s=0;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        s+=(long double)pow(-1,i)/(2*i+1);
    }
    printf("%Lf\n",s);
    return 0;
}

谁能告诉我为什么我不能达到小数点后 15 位的精度？我的目标不是打印 pi/4 的值，我只需要打印给定 n 的总和