获得π值的最快方法是什么？
我正在寻找获得π值的最快方法，作为个人挑战。更具体地说，我使用的方法不涉及使用#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)
{
return (double) (time1 - time0) / CLOCKS_PER_SEC;
}
int
main()
{
int i;
clock_t time1, time2;
double diff;
/* Warmup. The atan2 case catches GCC's atan folding (which would
* optimise the ``4 * atan(1) - M_PI'' to a no-op), if -fno-builtin
* is not used. */
TESTWITH(4 * atan(1))
TESTWITH(4 * atan2(1, 1))
#if defined(__GNUC__) && (defined(__i386__) || defined(__amd64__))
extern double fldpi();
TESTWITH(fldpi())
#endif
/* Actual tests start here. */
TESTWITH(atan2(0, -1))
TESTWITH(acos(-1))
TESTWITH(2 * asin(1))
TESTWITH(4 * atan2(1, 1))
TESTWITH(4 * atan(1))
return 0;
}
内联汇编内容（fldpi.c）仅适用于x86和x64系统：
double
fldpi()
{
double pi;
asm("fldpi" : "=t" (pi));
return pi;
}
构建脚本，构建我正在测试的所有配置（build.sh）：
#!/bin/sh
gcc -O3 -Wall -c -m32 -o fldpi-32.o fldpi.c
gcc -O3 -Wall -c -m64 -o fldpi-64.o fldpi.c
gcc -O3 -Wall -ffast-math -m32 -o pitimes1-32 pitimes.c fldpi-32.o
gcc -O3 -Wall -m32 -o pitimes2-32 pitimes.c fldpi-32.o -lm
gcc -O3 -Wall -fno-builtin -m32 -o pitimes3-32 pitimes.c fldpi-32.o -lm
gcc -O3 -Wall -ffast-math -m64 -o pitimes1-64 pitimes.c fldpi-64.o -lm
gcc -O3 -Wall -m64 -o pitimes2-64 pitimes.c fldpi-64.o -lm
gcc -O3 -Wall -fno-builtin -m64 -o pitimes3-64 pitimes.c fldpi-64.o -lm
除了在各种编译器标志之间进行测试之外（我已经将32位与64位进行了比较，因为优化不同），我也尝试切换测试的顺序。但是，atan2(0, -1)版本每次仍然排在首位。
25 个答案:
答案 0 :(得分：197)
如上所述，Monte Carlo method应用了一些很棒的概念，但显然不是最快的，不是长期的，不是任何合理的措施。此外，这一切都取决于您正在寻找什么样的准确性。我所知道的最快的π是硬编码的数字。查看Pi和Pi[PDF]，有很多公式。
这是一种快速收敛的方法 - 每次迭代大约14位数。当前最快的应用程序PiFast将此公式与FFT一起使用。我只会编写公式，因为代码很简单。这个公式几乎是由Ramanujan and discovered by Chudnovsky找到的。实际上他是如何计算出数十亿个数字的 - 所以它不是一种无视的方法。该公式将迅速溢出，因为我们正在划分阶乘，所以延迟这样的计算以删除术语将是有利的。
其中，
以下是Brent–Salamin algorithm。维基百科提到，当 a 和 b “足够接近”时，（a + b）²/ 4t 将是π的近似值。我不确定“足够接近”意味着什么，但是从我的测试来看，一次迭代得到2位数，两次得到7位，三次得到15次，当然这是双打，所以根据它的表示可能有错误 true 计算可能更准确。
let pi_2 iters =
let rec loop_ a b t p i =
if i = 0 then a,b,t,p
else
let a_n = (a +. b) /. 2.0
and b_n = sqrt (a*.b)
and p_n = 2.0 *. p in
let t_n = t -. (p *. (a -. a_n) *. (a -. a_n)) in
loop_ a_n b_n t_n p_n (i - 1)
in
let a,b,t,p = loop_ (1.0) (1.0 /. (sqrt 2.0)) (1.0/.4.0) (1.0) iters in
(a +. b) *. (a +. b) /. (4.0 *. t)
最后，一些pi高尔夫球（800位数）怎么样？ 160个字符！
int a=10000,b,c=2800,d,e,f[2801],g;main(){for(;b-c;)f[b++]=a/5;for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a)for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b);}
答案 1 :(得分：110)
我非常喜欢这个程序，因为它通过查看自己的区域来近似π。
IOCCC 1988：westley.c
#define _ -F<00||--F-OO--; int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO() { _-_-_-_ _-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_ _-_-_-_ }
答案 2 :(得分：75)
以下是我在高中学习计算pi的技术的一般描述。
我只是分享这个，因为我认为很简单，任何人都可以无限期地记住它，而且它会教你“蒙特卡罗”方法的概念 - 这是获得不立即得到答案的统计方法似乎可以通过随机过程进行推理。
画一个正方形，并在该正方形内刻一个象限（四分之一半圆）（一个半径等于正方形边的象限，所以它尽可能多地填充正方形）
现在在广场上投掷飞镖，并记录它落地的地方 - 也就是说，在广场内的任何地方选择一个随机点。当然，它降落在广场内，但它是否在半圆内？记录这个事实。
多次重复此过程 - 您会发现半圆内的点数与投掷的总数之比，称为此比率x。
由于正方形的面积是r乘以r，因此可以推断出半圆的面积是r乘以r的x倍（即x乘以r的平方）。因此x乘4将给你pi。
这不是一种快速使用的方法。但这是蒙特卡罗方法的一个很好的例子。如果你环顾四周，你可能会发现，除了你的计算技能之外的许多问题都可以通过这些方法解决。
答案 3 :(得分：54)
为了完整性，一个C ++模板版本，对于优化构建，它将在编译时计算PI的近似值，并将内联到单个值。
#include <iostream>
template<int I>
struct sign
{
enum {value = (I % 2) == 0 ? 1 : -1};
};
template<int I, int J>
struct pi_calc
{
inline static double value ()
{
return (pi_calc<I-1, J>::value () + pi_calc<I-1, J+1>::value ()) / 2.0;
}
};
template<int J>
struct pi_calc<0, J>
{
inline static double value ()
{
return (sign<J>::value * 4.0) / (2.0 * J + 1.0) + pi_calc<0, J-1>::value ();
}
};
template<>
struct pi_calc<0, 0>
{
inline static double value ()
{
return 4.0;
}
};
template<int I>
struct pi
{
inline static double value ()
{
return pi_calc<I, I>::value ();
}
};
int main ()
{
std::cout.precision (12);
const double pi_value = pi<10>::value ();
std::cout << "pi ~ " << pi_value << std::endl;
return 0;
}
注意我＆gt;如图10所示，优化的构建可能很慢，同样对于非优化的运行。对于12次迭代，我相信有大约80k次调用value（）（没有记忆）。
答案 4 :(得分：42)
实际上有一本专门用于计算\ pi：'Pi和AGM'的快速方法的全书，其中包括Jonathan和Peter Borwein（available on Amazon）
我研究了AGM和相关的算法：它非常有趣（尽管有时非常重要）。
请注意，要实现大多数现代算法来计算\ pi，你需要一个多精度算术库（GMP是一个很好的选择，尽管自从我上次使用它以来已经有一段时间了。）
最佳算法的时间复杂度在O（M（n）log（n））中，其中M（n）是两个n位整数相乘的时间复杂度（M（n）= O（n log（n）log（log（n）））使用基于FFT的算法，这在计算\ pi的数字时通常是需要的，并且这种算法在GMP中实现。
请注意，尽管算法背后的数学可能并不简单，但算法本身通常只有几行伪代码，而且它们的实现通常非常简单（如果您选择不编写自己的多精度算法： - ））。
答案 5 :(得分：41)
以下答案以最快的方式准确地执行此操作 - 以最少的计算工作量。即使你不喜欢这个答案，你也必须承认这确实是获得PI价值的最快方法。
最快获取Pi值的方法是：
1）选择您喜欢的编程语言 2）加载其数学库 3）并发现Pi已经在那里定义 - 准备好使用了！
如果您手头没有数学库..
SECOND FASTEST 方式（更通用的解决方案）是：
在互联网上查找Pi，例如这里：
http://www.eveandersson.com/pi/digits/1000000（100万位...你的浮点精度是多少？）
或在这里：
http://3.141592653589793238462643383279502884197169399375105820974944592.com/
或在这里：
http://en.wikipedia.org/wiki/Pi
找到你想要使用的精确算术所需的数字真的很快，通过定义常量，你可以确保不浪费宝贵的CPU时间。
这不仅是一个部分幽默的答案，而且实际上，如果有人继续在实际应用程序中计算Pi的价值......那将是一个相当大的浪费CPU时间，不是吗？至少我没有看到试图重新计算它的真实应用程序。
亲爱的主持人：请注意OP问：“获取PI价值的最快方式”
答案 6 :(得分：26)
BBP formula允许你计算第n个数字 - 在基数2（或16） - 而不必先打扰先前的n-1个数字：）
答案 7 :(得分：22)
我没有将pi定义为常量，而是始终使用acos(-1)。
答案 8 :(得分：21)
答案 9 :(得分：21)
如果this article为真，则创建的algorithm that Bellard可能是最快的可用之一。他使用DESKTOP PC创建了pi到2.7 TRILLION数字！
......他已发表了他的work here
好工作Bellard，你是先锋！
答案 10 :(得分：20)
这是一种“经典”方法，非常容易实现。 这个实现，在python（不是那么快的语言）中做到了：
from math import pi
from time import time
precision = 10**6 # higher value -> higher precision
# lower value -> higher speed
t = time()
calc = 0
for k in xrange(0, precision):
calc += ((-1)**k) / (2*k+1.)
calc *= 4. # this is just a little optimization
t = time()-t
print "Calculated: %.40f" % calc
print "Costant pi: %.40f" % pi
print "Difference: %.40f" % abs(calc-pi)
print "Time elapsed: %s" % repr(t)
您可以找到更多信息here。
无论如何，在python中获得精确的你想要的pi值的最快方法是：
from gmpy import pi
print pi(3000) # the rule is the same as
# the precision on the previous code
这里是gmpy pi方法的源代码，我不认为代码在这种情况下与注释一样有用：
static char doc_pi[]="\
pi(n): returns pi with n bits of precision in an mpf object\n\
";
/* This function was originally from netlib, package bmp, by
* Richard P. Brent. Paulo Cesar Pereira de Andrade converted
* it to C and used it in his LISP interpreter.
*
* Original comments:
*
* sets mp pi = 3.14159... to the available precision.
* uses the gauss-legendre algorithm.
* this method requires time o(ln(t)m(t)), so it is slower
* than mppi if m(t) = o(t**2), but would be faster for
* large t if a faster multiplication algorithm were used
* (see comments in mpmul).
* for a description of the method, see - multiple-precision
* zero-finding and the complexity of elementary function
* evaluation (by r. p. brent), in analytic computational
* complexity (edited by j. f. traub), academic press, 1976, 151-176.
* rounding options not implemented, no guard digits used.
*/
static PyObject *
Pygmpy_pi(PyObject *self, PyObject *args)
{
PympfObject *pi;
int precision;
mpf_t r_i2, r_i3, r_i4;
mpf_t ix;
ONE_ARG("pi", "i", &precision);
if(!(pi = Pympf_new(precision))) {
return NULL;
}
mpf_set_si(pi->f, 1);
mpf_init(ix);
mpf_set_ui(ix, 1);
mpf_init2(r_i2, precision);
mpf_init2(r_i3, precision);
mpf_set_d(r_i3, 0.25);
mpf_init2(r_i4, precision);
mpf_set_d(r_i4, 0.5);
mpf_sqrt(r_i4, r_i4);
for (;;) {
mpf_set(r_i2, pi->f);
mpf_add(pi->f, pi->f, r_i4);
mpf_div_ui(pi->f, pi->f, 2);
mpf_mul(r_i4, r_i2, r_i4);
mpf_sub(r_i2, pi->f, r_i2);
mpf_mul(r_i2, r_i2, r_i2);
mpf_mul(r_i2, r_i2, ix);
mpf_sub(r_i3, r_i3, r_i2);
mpf_sqrt(r_i4, r_i4);
mpf_mul_ui(ix, ix, 2);
/* Check for convergence */
if (!(mpf_cmp_si(r_i2, 0) &&
mpf_get_prec(r_i2) >= (unsigned)precision)) {
mpf_mul(pi->f, pi->f, r_i4);
mpf_div(pi->f, pi->f, r_i3);
break;
}
}
mpf_clear(ix);
mpf_clear(r_i2);
mpf_clear(r_i3);
mpf_clear(r_i4);
return (PyObject*)pi;
}
编辑：我在剪切和粘贴以及识别方面遇到了一些问题，无论如何，您都可以找到来源here。
答案 11 :(得分：19)
如果以最快的速度表示输入代码的速度最快，这里是golfscript解决方案：
;''6666,-2%{2+.2/@*\/10.3??2*+}*`1000<~\;
答案 12 :(得分：17)
使用类似Machin的公式
176 * arctan (1/57) + 28 * arctan (1/239) - 48 * arctan (1/682) + 96 * arctan(1/12943)
[; \left( 176 \arctan \frac{1}{57} + 28 \arctan \frac{1}{239} - 48 \arctan \frac{1}{682} + 96 \arctan \frac{1}{12943}\right) ;], for you TeX the World people.
在Scheme中实现，例如：
(+ (- (+ (* 176 (atan (/ 1 57))) (* 28 (atan (/ 1 239)))) (* 48 (atan (/ 1 682)))) (* 96 (atan (/ 1 12943))))
答案 13 :(得分：16)
如果您愿意使用近似值，355 / 113适用于6位十进制数字，并且具有可用于整数表达式的附加优势。这些日子并不重要，因为“浮点数学协处理器”不再具有任何意义，但它曾经非常重要。
答案 14 :(得分：15)
Pi正好是3！ [教授弗林克（辛普森一家）]
笑话，但这是C＃中的一个（需要.NET-Framework）。
using System;
using System.Text;
class Program {
static void Main(string[] args) {
int Digits = 100;
BigNumber x = new BigNumber(Digits);
BigNumber y = new BigNumber(Digits);
x.ArcTan(16, 5);
y.ArcTan(4, 239);
x.Subtract(y);
string pi = x.ToString();
Console.WriteLine(pi);
}
}
public class BigNumber {
private UInt32[] number;
private int size;
private int maxDigits;
public BigNumber(int maxDigits) {
this.maxDigits = maxDigits;
this.size = (int)Math.Ceiling((float)maxDigits * 0.104) + 2;
number = new UInt32[size];
}
public BigNumber(int maxDigits, UInt32 intPart)
: this(maxDigits) {
number[0] = intPart;
for (int i = 1; i < size; i++) {
number[i] = 0;
}
}
private void VerifySameSize(BigNumber value) {
if (Object.ReferenceEquals(this, value))
throw new Exception("BigNumbers cannot operate on themselves");
if (value.size != this.size)
throw new Exception("BigNumbers must have the same size");
}
public void Add(BigNumber value) {
VerifySameSize(value);
int index = size - 1;
while (index >= 0 && value.number[index] == 0)
index--;
UInt32 carry = 0;
while (index >= 0) {
UInt64 result = (UInt64)number[index] +
value.number[index] + carry;
number[index] = (UInt32)result;
if (result >= 0x100000000U)
carry = 1;
else
carry = 0;
index--;
}
}
public void Subtract(BigNumber value) {
VerifySameSize(value);
int index = size - 1;
while (index >= 0 && value.number[index] == 0)
index--;
UInt32 borrow = 0;
while (index >= 0) {
UInt64 result = 0x100000000U + (UInt64)number[index] -
value.number[index] - borrow;
number[index] = (UInt32)result;
if (result >= 0x100000000U)
borrow = 0;
else
borrow = 1;
index--;
}
}
public void Multiply(UInt32 value) {
int index = size - 1;
while (index >= 0 && number[index] == 0)
index--;
UInt32 carry = 0;
while (index >= 0) {
UInt64 result = (UInt64)number[index] * value + carry;
number[index] = (UInt32)result;
carry = (UInt32)(result >> 32);
index--;
}
}
public void Divide(UInt32 value) {
int index = 0;
while (index < size && number[index] == 0)
index++;
UInt32 carry = 0;
while (index < size) {
UInt64 result = number[index] + ((UInt64)carry << 32);
number[index] = (UInt32)(result / (UInt64)value);
carry = (UInt32)(result % (UInt64)value);
index++;
}
}
public void Assign(BigNumber value) {
VerifySameSize(value);
for (int i = 0; i < size; i++) {
number[i] = value.number[i];
}
}
public override string ToString() {
BigNumber temp = new BigNumber(maxDigits);
temp.Assign(this);
StringBuilder sb = new StringBuilder();
sb.Append(temp.number[0]);
sb.Append(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator);
int digitCount = 0;
while (digitCount < maxDigits) {
temp.number[0] = 0;
temp.Multiply(100000);
sb.AppendFormat("{0:D5}", temp.number[0]);
digitCount += 5;
}
return sb.ToString();
}
public bool IsZero() {
foreach (UInt32 item in number) {
if (item != 0)
return false;
}
return true;
}
public void ArcTan(UInt32 multiplicand, UInt32 reciprocal) {
BigNumber X = new BigNumber(maxDigits, multiplicand);
X.Divide(reciprocal);
reciprocal *= reciprocal;
this.Assign(X);
BigNumber term = new BigNumber(maxDigits);
UInt32 divisor = 1;
bool subtractTerm = true;
while (true) {
X.Divide(reciprocal);
term.Assign(X);
divisor += 2;
term.Divide(divisor);
if (term.IsZero())
break;
if (subtractTerm)
this.Subtract(term);
else
this.Add(term);
subtractTerm = !subtractTerm;
}
}
}
答案 15 :(得分：15)
使用D。
在编译时计算PI（从DSource.org复制）
/** Calculate pi at compile time
*
* Compile with dmd -c pi.d
*/
module calcpi;
import meta.math;
import meta.conv;
/** real evaluateSeries!(real x, real metafunction!(real y, int n) term)
*
* Evaluate a power series at compile time.
*
* Given a metafunction of the form
* real term!(real y, int n),
* which gives the nth term of a convergent series at the point y
* (where the first term is n==1), and a real number x,
* this metafunction calculates the infinite sum at the point x
* by adding terms until the sum doesn't change any more.
*/
template evaluateSeries(real x, alias term, int n=1, real sumsofar=0.0)
{
static if (n>1 && sumsofar == sumsofar + term!(x, n+1)) {
const real evaluateSeries = sumsofar;
} else {
const real evaluateSeries = evaluateSeries!(x, term, n+1, sumsofar + term!(x, n));
}
}
/*** Calculate atan(x) at compile time.
*
* Uses the Maclaurin formula
* atan(z) = z - z^3/3 + Z^5/5 - Z^7/7 + ...
*/
template atan(real z)
{
const real atan = evaluateSeries!(z, atanTerm);
}
template atanTerm(real x, int n)
{
const real atanTerm = (n & 1 ? 1 : -1) * pow!(x, 2*n-1)/(2*n-1);
}
/// Machin's formula for pi
/// pi/4 = 4 atan(1/5) - atan(1/239).
pragma(msg, "PI = " ~ fcvt!(4.0 * (4*atan!(1/5.0) - atan!(1/239.0))) );
答案 16 :(得分：15)
双打：
4.0 * (4.0 * Math.Atan(0.2) - Math.Atan(1.0 / 239.0))
这将精确到14个小数位，足以填充一个双倍（不准确可能是因为弧切线中的其余小数被截断）。
Seth，它是3.14159265358979323846 3 ，而不是64。
答案 17 :(得分：13)
这个版本（在Delphi中）并不特别，但它至少比the version Nick Hodge posted on his blog :)快。在我的机器上，进行十亿次迭代需要大约16秒，值为 3.14159265 25879（准确部分以粗体显示）。
program calcpi;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
start, finish: TDateTime;
function CalculatePi(iterations: integer): double;
var
numerator, denominator, i: integer;
sum: double;
begin
{
PI may be approximated with this formula:
4 * (1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 .......)
//}
numerator := 1;
denominator := 1;
sum := 0;
for i := 1 to iterations do begin
sum := sum + (numerator/denominator);
denominator := denominator + 2;
numerator := -numerator;
end;
Result := 4 * sum;
end;
begin
try
start := Now;
WriteLn(FloatToStr(CalculatePi(StrToInt(ParamStr(1)))));
finish := Now;
WriteLn('Seconds:' + FormatDateTime('hh:mm:ss.zz',finish-start));
except
on E:Exception do
Writeln(E.Classname, ': ', E.Message);
end;
end.
答案 18 :(得分：12)
如果你想计算π值的近似值（由于某种原因），你应该尝试二进制提取算法。 Bellard's的BBP改进给出了O（N ^ 2）中的PI。
如果你想获得π值的近似值来进行计算，那么：
PI = 3.141592654
当然，这只是一个近似值，并不完全准确。它的价格略高于0.00000000004102。 （四个十万亿分之一，约 4 / 10,000,000,000 ）。
如果你想用π做 math ，那么给自己一个铅笔和纸或计算机代数包，并使用π的精确值π。
如果你真的想要一个公式，这个很有趣：
π= - i ln（-1）
答案 19 :(得分：12)
在过去，使用小字大小和缓慢或不存在的浮点运算，我们曾经做过这样的事情：
/* Return approximation of n * PI; n is integer */
#define pi_times(n) (((n) * 22) / 7)
对于不需要很高精度的应用程序（例如视频游戏），这非常快且足够准确。
答案 20 :(得分：11)
如果你想要的只是第N个数字，那就是着名的 BBP formula 在十六进制中很有用
答案 21 :(得分：1)
从圆形区域计算π： - ）
<input id="range" type="range" min="10" max="960" value="10" step="50" oninput="calcPi()">
<br>
<div id="cont"></div>
<script>
function generateCircle(width) {
var c = width/2;
var delta = 1.0;
var str = "";
var xCount = 0;
for (var x=0; x <= width; x++) {
for (var y = 0; y <= width; y++) {
var d = Math.sqrt((x-c)*(x-c) + (y-c)*(y-c));
if (d > (width-1)/2) {
str += '.';
}
else {
xCount++;
str += 'o';
}
str += " "
}
str += "\n";
}
var pi = (xCount * 4) / (width * width);
return [str, pi];
}
function calcPi() {
var e = document.getElementById("cont");
var width = document.getElementById("range").value;
e.innerHTML = "<h4>Generating circle...</h4>";
setTimeout(function() {
var circ = generateCircle(width);
e.innerHTML = "<pre>" + "π = " + circ[1].toFixed(2) + "\n" + circ[0] +"</pre>";
}, 200);
}
calcPi();
</script>
答案 22 :(得分：0)
更好的方法
要获得标准常量（如 pi ）或标准概念的输出，我们应该首先使用您正在使用的语言提供的builtins方法。它将以最快的方式和最佳方式返回价值。我正在使用python来获得获得值pi的最快方法
- 数学库的pi变量。数学库将变量pi存储为常量。
math_pi.py
import math
print math.pi
使用linux /usr/bin/time -v python math_pi.py
输出：
Command being timed: "python math_pi.py"
User time (seconds): 0.01
System time (seconds): 0.01
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.03
- 使用数学cos算法
acos_pi.py
import math
print math.acos(-1)
使用linux /usr/bin/time -v python acos_pi.py
输出：
Command being timed: "python acos_pi.py"
User time (seconds): 0.02
System time (seconds): 0.01
Percent of CPU this job got: 94%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.03
bbp_pi.py
from decimal import Decimal, getcontext
getcontext().prec=100
print sum(1/Decimal(16)**k *
(Decimal(4)/(8*k+1) -
Decimal(2)/(8*k+4) -
Decimal(1)/(8*k+5) -
Decimal(1)/(8*k+6)) for k in range(100))
使用linux /usr/bin/time -v python bbp_pi.py
输出：
Command being timed: "python c.py"
User time (seconds): 0.05
System time (seconds): 0.01
Percent of CPU this job got: 98%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.06
所以最好的方法是使用语言提供的builtins方法，因为它们是最快且最好的输出。在python中使用math.pi
答案 23 :(得分：0)
如果您不介意执行平方根和几个反函数，则Chudnovsky算法的速度非常快。只需2次迭代即可收敛到双精度。
/*
Chudnovsky algorithm for computing PI
*/
#include <iostream>
#include <cmath>
using namespace std;
double calc_PI(int K=2) {
static const int A = 545140134;
static const int B = 13591409;
static const int D = 640320;
const double ID3 = 1./ (double(D)*double(D)*double(D));
double sum = 0.;
double b = sqrt(ID3);
long long int p = 1;
long long int a = B;
sum += double(p) * double(a)* b;
// 2 iterations enough for double convergence
for (int k=1; k<K; ++k) {
// A*k + B
a += A;
// update denominator
b *= ID3;
// p = (-1)^k 6k! / 3k! k!^3
p *= (6*k)*(6*k-1)*(6*k-2)*(6*k-3)*(6*k-4)*(6*k-5);
p /= (3*k)*(3*k-1)*(3*k-2) * k*k*k;
p = -p;
sum += double(p) * double(a)* b;
}
return 1./(12*sum);
}
int main() {
cout.precision(16);
cout.setf(ios::fixed);
for (int k=1; k<=5; ++k) cout << "k = " << k << " PI = " << calc_PI(k) << endl;
return 0;
}
结果：
k = 1 PI = 3.1415926535897341
k = 2 PI = 3.1415926535897931
k = 3 PI = 3.1415926535897931
k = 4 PI = 3.1415926535897931
k = 5 PI = 3.1415926535897931
答案 24 :(得分：0)
基本上是C版本的回形针优化器的答案，并且更加简化了：
#include <stdio.h>
#include <math.h>
double calc_PI(int K) {
static const int A = 545140134;
static const int B = 13591409;
static const int D = 640320;
const double ID3 = 1.0 / ((double) D * (double) D * (double) D);
double sum = 0.0;
double b = sqrt(ID3);
long long int p = 1;
long long int a = B;
sum += (double) p * (double) a * b;
for (int k = 1; k < K; ++k) {
a += A;
b *= ID3;
p *= (6 * k) * (6 * k - 1) * (6 * k - 2) * (6 * k - 3) * (6 * k - 4) * (6 * k - 5);
p /= (3 * k) * (3 * k - 1) * (3 * k - 2) * k * k * k;
p = -p;
sum += (double) p * (double) a * b;
}
return 1.0 / (12 * sum);
}
int main() {
for (int k = 1; k <= 5; ++k) {
printf("k = %i, PI = %.16f\n", k, calc_PI(k));
}
}
但为简化起见，此算法采用Chudnovsky公式，如果您不太了解代码，则可以完全简化。
摘要：我们将获得1到5之间的数字，并将其添加到用于获取PI的函数中。然后给您3个数字：545140134（A），13591409（B），640320（D）。然后，我们将D作为double使用自己乘以3到另一个double（ID3）。然后，我们将ID3的平方根放入另一个double（b）中，并分配2个数字：1（p），B的值（a）。 请注意，C不区分大小写。然后，将double中所有p，a和b的值相乘，将创建一个double（和）。然后循环，直到为该函数指定的数字开始，然后将A的值加到a，b的值乘以ID3，p的值将乘以多个值，我希望您可以理解，并且也除以多个值好。总和将再次与p，a和b相加，并且循环将重复进行，直到循环数的值大于或等于5。然后，将总和乘以12，然后由函数返回，得出的结果为PI。
好的，那很长，但是我想你会理解的...
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？