πの値を取得する最も速い方法は何ですか？
https://stackoverflow.com/questions/19
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
個人的な課題として、πの値を取得するための最速の方法を探しています。具体的には、 M_PI などの #define 定数を使用したり、数値をハードコーディングしたりしない方法を使用しています。
以下のプログラムは、私が知っているさまざまな方法をテストします。インラインアセンブリバージョンは、理論的には最速のオプションですが、明らかに移植性はありません。他のバージョンと比較するためのベースラインとしてそれを含めました。組み込みのテストでは、 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;
}
およびx86およびx64システムでのみ動作するインラインアセンブリ（ fldpi.c ）：
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）バージョンは常にトップに表示されます。
解決
モンテカルロ法は、前述のとおり、いくつかの優れた概念を適用しますが、明らかに、最速でも、ロングショットでも、合理的な手段でもありません。また、それはすべて、どのような精度を求めているかに依存します。最速＆＃960;私が知っているのは、数字がハードコードされているものです。 Pi および Pi [PDF] 、多くの式があります。
これは、迅速に収束する方法です＆＃8212;反復あたり約14桁。現在最も速いアプリケーションである PiFast は、この式を使用しますFFTを使用します。コードは簡単なので、式を書くだけです。この式はほとんどラマヌジャンによって発見され、Chudnovskyによって発見されました。実際に、彼は数十億桁の数を計算しました＆＃8212;無視する方法ではありません。数式はすぐにオーバーフローし、階乗を分割しているため、そのような計算を遅らせて用語を削除すると有利です。
どこで、
以下は Brent＆＃8211; Salaminアルゴリズムです。 。ウィキペディアでは、 a と b が「十分に近い」場合、その後、（a + b）＆＃178; / 4t は＆＃960;の近似値になります。何が「十分に近い」かわからないつまり、私のテストでは、1回の反復で2桁、2回で7、3回で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)
最後に、パイゴルフ（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);}
他のヒント
このプログラムは＆＃960;に近いため、本当に気に入っています。独自の領域を見ることで。
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() { _-_-_-_ _-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_ _-_-_-_ }
これは、高校で学んだpiの計算手法の一般的な説明です。
これを共有するのは、誰でも簡単に覚えることができるほどシンプルだと思うからです。さらに、「モンテカルロ」の概念を教えてくれます。メソッド-ランダムなプロセスではすぐに推測できないように思われる回答に到達する統計的方法です。
正方形を描き、その正方形の内側に象限（半円の4分の1）を刻みます（半径が正方形の辺に等しい象限なので、可能な限り正方形を埋めます）
今、正方形に投げ矢を投げ、それが着地した場所を記録します-つまり、正方形内の任意の点を選択します。もちろん、それは正方形の内側に落ちましたが、半円の内側にありますか？この事実を記録します。
このプロセスを何度も繰り返します-半円内のポイント数とスローされた合計数の比率があることがわかります。この比率をxと呼びます。
正方形の面積はr x rであるため、半円の面積はx x r x r（つまり、x x rの2乗）であると推定できます。したがって、xの4倍でpiが得られます。
これは簡単な方法ではありません。しかし、これはモンテカルロ法の良い例です。周りを見渡せば、そうでなければ計算スキル以外の多くの問題がそのような方法で解決できることに気付くかもしれません。
完全性のために、最適化されたビルドのために、コンパイル時にPIの近似値を計算し、単一の値にインライン化するC ++テンプレートバージョン。
#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回の反復で、value（）の呼び出しは約8万回あると思います（メモ化がない場合）。
実際には、\ pi： 'Pi and the AGM'の計算のための fast メソッドに特化した本全体があります（JonathanおよびPeter Borwein著（ Amazonで利用可能）。
私はAGMと関連するアルゴリズムをかなり研究しました：それは非常に興味深いものですが（時には自明ではありません）。
\ piを計算するための最新のアルゴリズムを実装するには、多精度演算ライブラリ（ GMP が必要です）良い選択ですが、最後に使用してからしばらく経ちました。）
最良のアルゴリズムの時間複雑度はO（M（n）log（n））にあります。ここで、M（n）は2つのnビット整数の乗算の時間複雑度（M（n）= O（n log（n）log（log（n）））FFTベースのアルゴリズムを使用します。これは通常\ piの数字を計算するときに必要であり、そのようなアルゴリズムはGMPで実装されています。
アルゴリズムの背後にある数学は簡単ではないかもしれませんが、アルゴリズム自体は通常数行の擬似コードであり、その実装は通常非常に簡単です（独自の多精度演算を記述しないことを選択した場合：- ））。
次の回答は、最小のコンピューティング労力で、可能な限り高速な方法でこれを正確に行う方法に答えます。答えが気に入らなくても、PIの価値を得る最も速い方法であることを認めなければなりません。
Piの価値を得るための最速の方法は次のとおりです。
1）お気に入りのプログラミング言語を選択しました 2）数学ライブラリをロードする 3）そして、Piがすでに定義されていることを確認します-すぐに使用できます！
手元に数学ライブラリがない場合。
2番目に速い方法（より普遍的なソリューション）は次のとおりです。
インターネットでPiを検索します。ここ：
http://www.eveandersson.com/pi/digits/1000000 （100万桁..浮動小数点の精度は？）
またはここ：
http://3.141592653589793238462643383279502884197169399375105820974944592.com/
またはここ：
http://en.wikipedia.org/wiki/Pi
使用したい精度の計算に必要な桁を見つけるのは非常に高速であり、定数を定義することにより、貴重なCPU時間を無駄にしないようにすることができます。
これは部分的にユーモラスな答えであるだけでなく、実際には、誰かが実際のアプリケーションでPiの値を計算すると、CPU時間のかなりの無駄になりますよね？少なくとも、これを再計算しようとする実際のアプリケーションは見当たりません。
モデレーターの皆様：OPが＆quot; PIの価値を得るための最も速い方法＆quot;
を尋ねたことに注意してください。BBP式を使用すると、n番目の数字を計算できます-2を底（または16）-最初に前のn-1桁を気にする必要もなく：）
piを定数として定義する代わりに、常に acos（-1）を使用します。
これは「クラシック」ですメソッド、非常に簡単に実装できます。 この実装は、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)
詳細については、こちらをご覧ください。
とにかく、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;
}
編集：切り取りと貼り付けと識別に問題がありましたが、とにかくソースこちら。
コードを入力するのが最速という場合は、 golfscript ソリューションがあります：
;''6666,-2%{2+.2/@*\/10.3??2*+}*`1000<~\;
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））））
近似値を使用する場合は、 355/113 が6桁の10進数に適しています。また、整数式で使用できるという利点もあります。 「浮動小数点演算コプロセッサ」など、最近ではそれほど重要ではありません。意味がなくなったが、かつては非常に重要だった。
doubleの場合：
4.0 * (4.0 * Math.Atan(0.2) - Math.Atan(1.0 / 239.0))
これは、小数点以下14桁まで正確で、2桁を埋めるのに十分です（不正確な理由は、おそらくアークタンジェントの残りの小数点が切り捨てられているためです）。
セスも、3.14159265358979323846 3 で、64ではありません。
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))) );
Piは正確に3です！ [教授フリンク（シンプソンズ）]
冗談ですが、これはC＃にあります（.NETフレームワークが必要です）。
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;
}
}
}
このバージョン（Delphi）は特別なものではありませんが、少なくとも Nick Hodgeが彼のブログに投稿したバージョン :)。私のマシンでは、10億回の反復を行うのに約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.
昔は、ワードサイズが小さく、浮動小数点演算が低速または存在しなかったため、以前は次のようなことをしていました。
/* Return approximation of n * PI; n is integer */
#define pi_times(n) (((n) * 22) / 7)
多くの精度を必要としないアプリケーション（ビデオゲームなど）の場合、これは非常に高速で十分に正確です。
＆＃960;の値の近似値を計算したい場合。 （何らかの理由で）、バイナリ抽出アルゴリズムを試す必要があります。 Bellardによる
＆＃960;の値の近似値を取得したい場合。計算を行うには：
PI = 3.141592654
確かに、これはあくまでも概算であり、完全に正確ではありません。 0.00000000004102より少し離れています。 （10兆分の4、約 4 / 10,000,000,000 ）。
＆＃960;で math を実行する場合は、鉛筆と紙またはコンピューター代数パッケージを入手し、＆＃960;の正確な値＆＃960;を使用します。 。
本当に数式が必要な場合、これは楽しいです：
＆＃960; =- i ln（-1）
Chrisが上に掲載したブレントの方法は非常に優れています。ブレントは一般に、任意精度の計算の分野では巨人です。
必要なのがN桁目だけの場合、有名な BBP式 16進数で便利です
円領域からのπの計算：-）
<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>
より良いアプローチ
pi などの標準定数または標準概念の出力を取得するには、まず、使用している言語で使用可能な組み込みメソッドを使用する必要があります。また、最速の方法で最高の方法で値を返します。私はPythonを使用して値piを取得する最速の方法を取得しています
- 数学ライブラリのpi変数。数学ライブラリは、変数piを定数として保存します。
math_pi.py
import math
print math.pi
Linuxのtimeユーティリティでスクリプトを実行します / 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
- arc cosメソッドを使用する
acos_pi.py
import math
print math.acos(-1)
Linuxのtimeユーティリティを使用してスクリプトを実行する / 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のtimeユーティリティでスクリプトを実行します / 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
したがって、最良の方法は、言語が提供する組み込みメソッドを使用することです。これは、言語を提供するために最も速く、最良であるためです。 Pythonではmath.piを使用します