我怎么计算PI在C#?
https://stackoverflow.com/questions/39395
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我如何可以计算出的价值PI使用C#?
我认为它将通过递归功能，如果是这样，那会是什么样以及是否有任何数学公式，以回来吗？
我不太挑剔的表现，主要是如何去了解它从一个学习的观点。
解决方案
如果你想递归:
PI = 2 * (1 + 1/3 * (1 + 2/5 * (1 + 3/7 * (...))))
这将成为后，一些重写的:
PI = 2 * F(1);
F(i)：
double F (int i) {
return 1 + i / (2.0 * i + 1) * F(i + 1);
}
艾萨克*牛顿(你可能已经听说他以前))想出了这个伎俩。注意我离开了结束条件，以保持它的简单。在现实生活中，你有种需要之一。
其他提示
关于如何使用：
double pi = Math.PI;
如果你想更精确的比，你将需要使用一种算法系统和小型的。
如果你仔细看到这个真的很好的指导:
你会发现在70页这个可爱的执行情况(与微小的变化从我身边):
static decimal ParallelPartitionerPi(int steps)
{
decimal sum = 0.0;
decimal step = 1.0 / (decimal)steps;
object obj = new object();
Parallel.ForEach(
Partitioner.Create(0, steps),
() => 0.0,
(range, state, partial) =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
decimal x = (i - 0.5) * step;
partial += 4.0 / (1.0 + x * x);
}
return partial;
},
partial => { lock (obj) sum += partial; });
return step * sum;
}
有几个真的，真的老把戏我很惊讶于看不到这里。
atan(1)==PI/4，这样一个老板栗当一个值得信赖的圆弧切功能是 现在是4*atan(1)条。
一个非常可爱，固定比例的估计，这使古老的西部22/7看起来像污垢 是355/113，这是好几位小数(至少三或四，我认为)。在某些情况下，这甚至是不够好整数的算术：乘355然后除以113.
355/113也很容易致力于存储器(一些人无论如何):数一，一个、三个、三个、五个、五个，记住，你的名字中的分母和分子(如果你忘记了这三重进在上面，一个微妙的思想通常是要理顺出来).
注意22/7让你：3.14285714，这是错误的，在千分之一.
355/113给你3.14159292这不是错误的，直到的十万分之.
Acc。to/usr/include/数学。h在我的盒子，M_PI是#define会：3.14159265358979323846 这可能是个好出来为止，因为它去。
教训你从估计PI的是，有很多的方式这样做， 没有人会永远是完美的，你有对它们进行排序通过使用目的。
355/113是一个古老的中国的估计，并且我相信它预期22/7通过了许多年。这是教会我的一个物理学教授当我是一个本科生.
很好地概括了不同算法：
我不确定关于复杂，要求高斯-德-Salamin算法在第一链接(我说O(N日志^2(N)日志(日志(N)))).
我鼓励你去尝试，不过，所收敛 真的 快。
还有，我真的不知道为什么，试图将一个相当简单的程序递归算法进入一个吗？
请注意，如果你有兴趣的性能，那么工作的一个有界限的精确度(通常，要求在一个'双重','浮动',...输出)并不真正意义，因为显而易见的答案在这样的情况下仅仅是硬编码的价值。
这里是一条关于计算PI在C#:
什么是PI?本周的圆除其直径。
在计算机图形，你可以绘图/画的圆中心在0,0从初始点x，y，下一点x，y'可以发现，采用一个简单的公式：x'=x+y/h：y'=y的x'/h
h通常是一个权力2以使鸿沟可以很容易地移位(或从中减去该指数对双).h还想要radius r你的圈子。一个简单的开始点将是x=r,y=0，然后计c步骤的数目，直到x <=0到情节的一个条之四个圆圈。PI4*c/r或PI4*c/h
递归来的任何伟大的深度，通常是不切实际的商业计划，但尾递归允许的算法表示递归，同时实现为一个循环。递归的搜索算法有时可以实施的使用排队，而不是过程的堆、搜索已经走回头路从死路一条，并采取另一种路径的原路返回这些要点可以放在一个队和多进程可以联合国-队列队点和试试其他途径。
计算这样的：
x = 1 - 1/3 + 1/5 - 1/7 + 1/9 (... etc as far as possible.)
PI = x * 4
你已经得到了Pi的!!!
这是最简单的方法我知道的。
PI值慢慢收敛的实际价值的Pi(3.141592165......).如果你迭代更多的时间，更好。
这是一个很好的办法(从 主要的维基百科上的条目pi);它收敛速度远远超过了简单的公式上讨论，是相当适合于递归的解决方案，如果你的意图是要追求递归作为一个学习的运动。(假设你之后的学习经验，我不会给任何实际代码。)
基础式是与上述相同，但这种做法平均水平的部分款项，以加速融合。
定义有两个参数的功能，pie(h w)，这样的：
pie(0,1) = 4/1
pie(0,2) = 4/1 - 4/3
pie(0,3) = 4/1 - 4/3 + 4/5
pie(0,4) = 4/1 - 4/3 + 4/5 - 4/7
... and so on
所以你的第一个机会，探讨递归的代码"水平的"计算为"宽度"参数增加了(为"高度"零)。
然后添加第二个层面与该公式：
pie(h, w) = (pie(h-1,w) + pie(h-1,w+1)) / 2
这是使用，当然，只有对价值观h大于零。
好的事情关于这个算法是，你可以很容易地模拟了一个电子表格检查你的代码作为探索产生的结果通过逐步更大的参数。你的时间计算的馅饼(10、10a)，只有一个近似值pi这就不够好对于大多数工程的目的。
Enumerable.Range(0, 100000000).Aggregate(0d, (tot, next) => tot += Math.Pow(-1d, next)/(2*next + 1)*4)
using System;
namespace Strings
{
class Program
{
static void Main(string[] args)
{
/* decimal pie = 1;
decimal e = -1;
*/
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start(); //added this nice stopwatch start routine
//leibniz formula in C# - code written completely by Todd Mandell 2014
/*
for (decimal f = (e += 2); f < 1000001; f++)
{
e += 2;
pie -= 1 / e;
e += 2;
pie += 1 / e;
Console.WriteLine(pie * 4);
}
decimal finalDisplayString = (pie * 4);
Console.WriteLine("pie = {0}", finalDisplayString);
Console.WriteLine("Accuracy resulting from approximately {0} steps", e/4);
*/
// Nilakantha formula - code written completely by Todd Mandell 2014
// π = 3 + 4/(2*3*4) - 4/(4*5*6) + 4/(6*7*8) - 4/(8*9*10) + 4/(10*11*12) - (4/(12*13*14) etc
decimal pie = 0;
decimal a = 2;
decimal b = 3;
decimal c = 4;
decimal e = 1;
for (decimal f = (e += 1); f < 100000; f++)
// Increase f where "f < 100000" to increase number of steps
{
pie += 4 / (a * b * c);
a += 2;
b += 2;
c += 2;
pie -= 4 / (a * b * c);
a += 2;
b += 2;
c += 2;
e += 1;
}
decimal finalDisplayString = (pie + 3);
Console.WriteLine("pie = {0}", finalDisplayString);
Console.WriteLine("Accuracy resulting from {0} steps", e);
stopwatch.Stop();
TimeSpan ts = stopwatch.Elapsed;
Console.WriteLine("Calc Time {0}", ts);
Console.ReadLine();
}
}
}
public static string PiNumberFinder(int digitNumber)
{
string piNumber = "3,";
int dividedBy = 11080585;
int divisor = 78256779;
int result;
for (int i = 0; i < digitNumber; i++)
{
if (dividedBy < divisor)
dividedBy *= 10;
result = dividedBy / divisor;
string resultString = result.ToString();
piNumber += resultString;
dividedBy = dividedBy - divisor * result;
}
return piNumber;
}
在任何生产方案，我会迫使你看起来价值，所需的小数点和储存为常量'的某个地方您的课程可以得到它。
(除非你写科学'Pi'特定的软件...)
关于...
...如何去关于它从一个学习的观点。
你是不是想学习程序的科学方法吗？或生产产量的软件吗？我希望社区认为，这是一个有效的问题并不挑剔.
在任何一种情况下，我认为写你自己的Pi是解决问题。德米特里*梅德表现出的'数学。PI'的定。攻击的另一个问题，在同样的空间！去通用牛顿的近似值，或者华而不实的东西.
@托马斯Kammeyer:
注意Atan(1.0)是相当常常硬编码，所以4*Atan(1.0)是不是一个真正的'算法'如果你叫库Atan功能(一个相当一些已经建议确实继续通过替代Atan(x)通过一系列的(或无限的产品)，然后评估它在x=1。
此外， 有极少数情况下你会需要pi在更精确比几十位 (它可以容易地硬编码!).我工作上应用程序的数学在那里，计算一些(相当复杂的)的数学对象(其中多项式与整系数)，我不得不这样做算术上的现实和复杂的数字(包括计算pi)，精度达到几百万位...但是，这不是非常经常'在现实生活':)
你可以看看下面的示例 代码.
我喜欢 这纸, 这解释了如何计算π根据泰勒系列扩大对于反正切.
纸启动的简单的假设
Atan(1)=π/4弧度
Atan(x)可以迭代地估计与泰勒系列
atan(x)=x-x^第3/3+x^5/5-x^7/7+x^9/9...
该文件指出为什么这不是特别有效的，并继续使一些逻辑改进的技术。他们还提供了一个样本计划，计算π到几千位数字，完整的源代码，其中包括无限精确的数学程序所必需的。
下面的链接表示了如何计算pi定根据其定义为一个整体，这可以写作为一个限制的总和，这是非常有意思：https://sites.google.com/site/rcorcs/posts/calculatingthepiconstant 该文件"Pi作为一个整体解释说："这个方法用在这个岗位。
首先，请注意，C#可以使用数学。PI领域。网的框架：
https://msdn.microsoft.com/en-us/library/system.math.pi(v=与110).aspx
好的特点是，它是一个完整的精度的两倍，既可以使用，或者比较计算的结果。该标签可在该网址具有类似的常数为C++、F#和视觉基础。
计算出更多的地方，你可以写你自己的延展精密码。一个快速码和合理的快速和容易的程序是：
Pi=4*[4*atan(1/5)-atan(1/239)]
这式和其他许多人，包括汇聚在一些，令人惊讶的快速率，例如50个数字每学期都在Wolfram:
PI(π) 可以通过使用计算 无限的系列.这里有两个例子：
格雷戈里-莱布尼茨系列：
π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 - ...
C#方法：
public static decimal GregoryLeibnizGetPI(int n)
{
decimal sum = 0;
decimal temp = 0;
for (int i = 0; i < n; i++)
{
temp = 4m / (1 + 2 * i);
sum += i % 2 == 0 ? temp : -temp;
}
return sum;
}
Nilakantha系列：
π=3+4/(2x3x4)-4/(4x5x6)+4/(6x7x8)-4/(8x9x10)+...
C#方法：
public static decimal NilakanthaGetPI(int n)
{
decimal sum = 0;
decimal temp = 0;
decimal a = 2, b = 3, c = 4;
for (int i = 0; i < n; i++)
{
temp = 4 / (a * b * c);
sum += i % 2 == 0 ? temp : -temp;
a += 2; b += 2; c += 2;
}
return 3 + sum;
}
输入参数 n 对于这两种功能的数量表示的迭代。
该Nilakantha系列比格雷戈里-莱布尼茨系列收敛更迅速。该方法可通过下列代码：
static void Main(string[] args)
{
const decimal pi = 3.1415926535897932384626433832m;
Console.WriteLine($"PI = {pi}");
//Nilakantha Series
int iterationsN = 100;
decimal nilakanthaPI = NilakanthaGetPI(iterationsN);
decimal CalcErrorNilakantha = pi - nilakanthaPI;
Console.WriteLine($"\nNilakantha Series -> PI = {nilakanthaPI}");
Console.WriteLine($"Calculation error = {CalcErrorNilakantha}");
int numDecNilakantha = pi.ToString().Zip(nilakanthaPI.ToString(), (x, y) => x == y).TakeWhile(x => x).Count() - 2;
Console.WriteLine($"Number of correct decimals = {numDecNilakantha}");
Console.WriteLine($"Number of iterations = {iterationsN}");
//Gregory-Leibniz Series
int iterationsGL = 1000000;
decimal GregoryLeibnizPI = GregoryLeibnizGetPI(iterationsGL);
decimal CalcErrorGregoryLeibniz = pi - GregoryLeibnizPI;
Console.WriteLine($"\nGregory-Leibniz Series -> PI = {GregoryLeibnizPI}");
Console.WriteLine($"Calculation error = {CalcErrorGregoryLeibniz}");
int numDecGregoryLeibniz = pi.ToString().Zip(GregoryLeibnizPI.ToString(), (x, y) => x == y).TakeWhile(x => x).Count() - 2;
Console.WriteLine($"Number of correct decimals = {numDecGregoryLeibniz}");
Console.WriteLine($"Number of iterations = {iterationsGL}");
Console.ReadKey();
}
以下产出显示，Nilakantha系列返回六个正确的小数位数的PI的一个百次迭代，而格雷戈里-莱布尼茨的一系列返回的五个正确的小数位数的PI有一百万迭代：
我的代码可以被测试>> 在这里，
这里是一个很好的方式：计算一系列1/x^2x从1到什么你想要更大的号码-好的馅饼的结果。结果乘以6和sqrt().这里是代码在c#(主要是唯一的):
static void Main(string[] args)
{
double counter = 0;
for (double i = 1; i < 1000000; i++)
{
counter = counter + (1 / (Math.Pow(i, 2)));
}
counter = counter * 6;
counter = Math.Sqrt(counter);
Console.WriteLine(counter);
}
public double PI = 22.0 / 7.0;
