① 用c语言编个程序,求π（派）
利用“正多边形逼近”的方法求出π的近似值
*程序说明与注释
#include<stdio.h>
#include<math.h>
int main()
{
double e=0.1,b=0.5,c,d;
long int i; /*i: 正多边形边数*/
for(i=6;;i*=2) /*正多边形边数加倍*/
{
d=1.0-sqrt(1.0-b*b); /*计算圆内接正多边形的边长*/
b=0.5*sqrt(b*b+d*d);
if(2*i*b-i*e<1e-15) break; /*精度达1e-15则停止计算*/
e=b; /*保存本次正多边形的边长作为下一次精度控制的依据*/
}
printf("pai=%.15lf\n",2*i*b); /*输出π值和正多边形的边数*/
printf("The number of edges of required polygon:%ld\n",i);
}
*问题分析与算法设计
利用“正多边形逼近”的方法求出π值在很早以前就存在，我们的先人祖冲之就是用这种方法在世界上第一个得到精确度达小数点后第6位的π值的。
利用圆内接正六边形边长等于半径的特点将边数翻番，作出正十二边形，求出边长，重复这一过程，就可获得所需精度的π的近似值。
假设单位圆内接多边形的边长为2b，边数为i，则边数加倍后新的正多边形的边长为：
x=√——————
2-2*√———
1-b*b
——————
2
周长为：
y=2 * i * x i:为加倍前的正多边形的边数
② 编C语言程序计算圆周率π，要求精确到2000位，用命令行参数实现
关键是数学知识,而不是计算机的知识...
http://hi..com/sunlovestar/blog/item/36fad5a20e12c1accaefd051.html
一、源程序
本文分析下面这个很流行的计算PI的小程序。下面这个程序初看起来似乎摸不到头脑，
不过不用担心，当你读完本文的时候就能够基本读懂它了。
程序一：很牛的计算Pi的程序
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);
}
二、数学公式
数学家们研究了数不清的方法来计算PI,这个程序所用的公式如下：
1 2 3 k
pi = 2 + --- * (2 + --- * (2 + --- * (2 + ... (2 + ---- * (2 + ... ))...)))
3 5 7 2k+1
至于这个公式为什么能够计算出PI，已经超出了本文的能力范围。
下面要做的事情就是要分析清楚程序是如何实现这个公式的。
我们先来验证一下这个公式：
程序二：Pi公式验证程序
#include "stdio.h"
void main()
{
float pi=2;
int i;
for(i=100;i>=1;i--)
pi=pi*(float)i/(2*i+1)+2;
printf("%f\n",pi);
getchar();
}
上面这个程序的结果是3.141593。
三、程序展开
在正式分析程序之前，我们需要对程序一进行一下展开。我们可以看出程序一都是使用
for循环来完成计算的，这样做虽然可以使得程序短小，但是却很难读懂。根据for循环
的运行顺序，我们可以把它展开为如下while循环的程序：
程序三：for转换为while之后的程序
int a=10000,b,c=2800,d,e,f[2801],g;
main() {
int i;
for(i=0;i<c;i++)
f[i]=a/5;
while(c!=0)
{
d=0;
g=c*2;
b=c;
while(1)
{
d=d+f[b]*a;
g--;
f[b]=d%g;
d=d/g;
g--;
b--;
if(b==0) break;
d=d*b;
}
c=c-14;
printf("%.4d",e+d/a);
e=d%a;
}
}
注：
for([1];[2];[3]) {[4];}
的运行顺序是[1],[2],[4],[3]。如果有逗号操作符，例如：d=0,g=c*2，则先运行d=0,
然后运行g=c*2,并且最终的结果是最后一个表达式的值，也就是这里的c*2。
下面我们就针对展开后的程序来分析。
四、程序分析
要想计算出无限精度的PI，我们需要上述的迭代公式运行无数次，并且其中每个分数也
是完全精确的，这在计算机中自然是无法实现的。那么基本实现思想就是迭代足够多次
，并且每个分数也足够精确，这样就能够计算出PI的前n位来。上面这个程序计算800位
，迭代公式一共迭代2800次。
int a=10000,b,c=2800,d,e,f[2801],g;
这句话中的2800就是迭代次数。
由于float或者double的精度远远不够，因此程序中使用整数类型（实际是长整型），分
段运算（每次计算4位）。我们可以看到输出语句 printf("%.4d",e+d/a); 其中%.4就是
把计算出来的4位输出，我们看到c每次减少14（ c=c-14;），而c的初始大小为2800，因
此一共就分了200段运算，并且每次输出4位，所以一共输出了800位。
由于使用整型数运算，因此有必要乘上一个系数，在这个程序中系数为1000，也就是说
，公式如下：
1 2 3 k
1000*pi = 2k+ --- * (2k+ --- * (2k+ --- * (2k+ ... (2k+ ---- * (2k+ ... )).
..)))
3 5 7 2k+1
这里的2k表示2000，也就是f[2801]数组初始化以后的数据,a=10000,a/5=2000,所以下面
的程序把f中的每个元素都赋值为2000：
for(i=0;i<c;i++)
f[i]=a/5;
你可能会觉得奇怪，为什么这里要把一个常数储存到数组中去，请继续往下看。
我们先来跟踪一下程序的运行：
while(c!=0) 假设这是第一次运行，c=2800，为迭代次数
{
d=0;
g=c*2; 这里的g是用来做k/(2k+1)中的分子
b=c; 这里的b是用来做k/(2k+1)中的分子
while(1)
{
d=d+f[b]*a; f中的所有的值都为2000，这里在计算时又把系数扩大了
a=10000倍。
这样做的目的稍候介绍，你可以看到
输出的时候是d/a,所以这不影
计算
g--;
f[b]=d%g; 先不管这一行
d=d/g; 第一次运行的g为2*2799+1，你可以看到g做了分母
g--;
b--;
if(b==0) break;
d=d*b; 这里的b为2799，可以看到d做了分子。
}
c=c-14;
printf("%.4d",e+d/a);
e=d%a;
}
只需要粗略的看看上面的程序，我们就大概知道它的确是使用的那个迭代公式来计算Pi
的了，不过不知道到现在为止你是否明白了f数组的用处。如果没有明白，请继续阅读。
d=d/g,这一行的目的是除以2k+1，我们知道之所以程序无法精确计算的原因就是这个除
法。即使用浮点数，答案也是不够精确的，因此直接用来计算800位的Pi是不可能的。那
么不精确的成分在哪里？很明显：就是那个余数d%g。程序用f数组把这个误差储存起来
，再下次计算的时候使用。现在你也应该知道为什么d=d+f[b]*a;中间需要乘上a了吧。
把分子扩大之后，才好把误差精确的算出来。
d如果不乘10000这个系数，则其值为2000，那么运行d=d/g；则是2000/(2*2799+1)，这
种整数的除法答案为0，根本无法迭代下去了。
现在我们知道程序就是把余数储存起来，作为下次迭代的时候的参数，那么为什么这么
做就可以使得下次迭代出来的结果为
接下来的4位数呢？
这实际上和我们在纸上作除法很类似：
0142
/——------
7 / 1
10
7
---------------
30
28
---------------
20
14
---------------
60
.....
我们可以发现，在做除法的时候，我们通常把余数扩大之后再来计算，f中既然储存的是
余数，而f[b]*a;则正好把这个余数扩大了a倍，然后如此循环下去，可以计算到任意精
度。
这里要说明的是，事实上每次计算出来的d并不一定只有4位数，例如第一次计算的时候
，d的值为31415926，输出4位时候，把低四位的值储存在e中间，e=d%a，也就是5926。
最后，这个c=c-14不太好理解。事实上没有这条语句，程序计算出来的仍然正确。只是
因为如果迭代2800次，无论分数如何精确，最后Pi的精度只能够达到800。
你可以把程序改为如下形式尝试一下：
for(i=0;i<800;i++)
{
d=0;
g=c*2;
b=c;
while(1)
{
d=d+f[b]*a;
g--;
f[b]=d%g;
d=d/g;
g--;
b--;
if(b==0) break;
d=d*b;
}
// c=c-14; 不要这句话。
printf("%.4d",e+d/a);
e=d%a;
}
最后的答案仍然正确。
不过我们可以看到内循环的次数是c次，也就是说每次迭代计算c次。而每次计算后续位
数的时候，迭代次数减少14，而不影响精度。为什么会这样，我没有研究。另外最后的
e+d/a,和e=d/a的作用就由读者自己考虑吧。
③ c语言求PI值，使其精度小于0.005，为什么运行不到结果啊，求高人解释
帮你研究了下 问题有两点
一 、while(j>=eps) 这句话的时候 j没初始化没有被赋值 怎么比啊？
建议改一下：
while(j>=eps)
{
t=t*i;
s=s*(2*i+1);
j=1.0*t/s;
sum=sum+j;
i++;
}
return sum*2;
}
改成 do while
do
{
t=t*i;
s=s*(2*i+1);
j=1.0*t/s;
sum=sum+j;
i++;
}
return sum*2;
}while(j>=eps)；
二、本程序当输入的精度 很精时 ，会发生溢出 当然这时候系统不会提示你溢出 而回运行得到错误的结果 即 你说的 不会的3.14.。。啊好像是3.09.。。
s=s*(2*i+1); //s 发生溢出了
故修改成：int i=1,s=1,t=1;------》double i=1,s=1,t=1; 这样就不会溢出了 ，随着精度的精确 越来越接近3.1415926
你可以试一下
好的话
请采纳
④ 急啊！请编写一个C语言程序，根据以下公式求π的值（要求满足精度0.0005，即某项小于0.0005时停止迭代）
#include ＜stdio.h＞
#include ＜math.h＞
double fun(double eps)
{
double s=1.0；float t=1,pi=0,n=1.0;
while((fabs(s))>=eps)
{
pi+=s;
t=n/(2*n+1);
s*=t;n++;
}
pi=pi*2;
return pi;
}
main()
{ double x;
printf("Input eps:");
scanf("%lf",&x); printf("\neps=%lf, PI=%lf\n",x,fun(x));
}
⑤ C语言求 π
C 语言是一种编译型语言, 每个程式执行时都从 main 函数开始执行, 所以每个 C 语言程序都必须包含一个且只能包含一个 main 函数, C 语言的语句每条语句以 ";" 作为结束符, 程式的写法可以不拘泥与格式, 但是要想写出好程式, 需要尽可能的每条语句分开, 写出自己和别人都能看懂的程式, C 语言本身提供了一些标准的函数库, 用来简化 C 程序的编写, 例如: stdio.h, 是 Standard Input Output (标准输入输出库), math.h 是 Math (数学函数库), 函数库所有定义的函数都会在 head (头文件) ".h" 中声明, 在使用标准头文件时, 要使用 C 语言编译器预处理关键字 #include (包含), C 语言的程序会在编译自动加入根据头文件的声明连接你在编程中使用的库函数, C 语言提供五种不同类型的数据类型, int (integter 整数型), float (浮点型), char (character 字符型), void (无值型), bool (boolean 布尔型), 提供基本的判断语句 if ... else, 循环结构 for, while, do.. while 和多分枝结构 switch, C 语言还提供两种写给别人帮助理解方式注释方式, 第一种是使用 // (双斜杠) 后面加注释内容, 注释内容仅限于本行的结束, 第二种是 /* ... */ (省略号中间是注释的内容) (单斜杠加星号开始, 星号加单斜杠结束) 的块注释.
以上的给你大概了解, 下面是对你的程式的等价变化, 和注释
#include <stdio.h> // 包含标注输入输出头文件
#include <math.h> // 包含数学函数头文件
int main() // main 函数, 是函数执行进入点
{
int s = 1; // 定义一个整数型变量 s, 并赋值初始值 1
float n, t, pi; // 定义三个浮点型变量 n, t, pi, 多个相同的定义可以写在一起用逗号作为分隔符
t = 1; // 给浮点型变量 t 赋值初始值 1
pi = 0; // 给浮点型变量 pi 赋值初始值 0
n = 1.0; // 给浮点型变量 n 赋值初始值 1
/* 下面的 fabs(t) 是调用 math 函数库里面的去绝对值函数, 这个值和1e-6 (表示1.0乘以10负六次方), 表示一个很小的值, 浮点数比较时, 和很小的数相比, 表示近似等于 0, while 是循环语句, 是下面的大括号里面的是否执行的条件
*/
while (fabs(t) < 1e-6)
{
pi = pi+t; // 将 pi 原来值加上 t, 所得值再赋值给 pi, 第一次执行, t 就是 1
n = n+2; // 和上面的相同的含义
s = -s; // 取 s 原值的相反数, 再赋值给 s
t = s / n; // t 取新的值, 作为下次循环的判断条件, 给下一次次执行 t 作预备
}
pi = pi * 4; // 以上计算的是π/4的值, 乘以4的得到π
printf("pi=%10.6f\n", pi); // 调用标准输出函数printf, 参数"pi=%10.6f\n" 是格式化输出的格式
return 0; // 表示程序执行成功
}
以上只是大概的解释, 在看看书, 了解吧
⑥ 用C语言求π
你的程序是模拟大量随机事件来求pi的近似值。有两点给你纠正的：
1、
x=(double)(rand()%10000);
y=(double)(rand()%10000);
x/、y都是小于10000的数表示（x，y）这个随机点是落在了长10000，宽10000的矩形也就是正方形中，所以if(x*x+y*y<=10000*1000)表示这个点落在了以10000为半径的圆内，所以，你的
if(x*x+y*y<=1)应该改为if(x*x+y*y<=10000000)。
2、
pi=(double)(a/MAX)*4.0;
pi=(double)(a/MAX)*4.0;由于MAX是10000,a<=9999,所以a永远小于MAX所以(a/MAX)永远等于0,所以你求出的pi值永远等于0。pi=(double)(a/MAX)*4.0等价于pi=(double)(0)*4.0等价于pi=0;在c语言或者c++中两个int型的变量相除结果还是int型的，如果分母大于分子结果则为0，java中好像也是的。但是分子分母中只要有一者是double或floati型的，那个整型会自动向高精度的数据类型转换。所以你的pi=(double)(a/MAX)*4.0;应更正为pi=a/(double)MAX *4.0;或者
pi=(double)a/MAX*4/0;或者把double替换为float也可以滴
在我的机器上最终模拟出的pi的近似值是
⑦ 如何用C语言得出派值，数学老师要求精确到小数点后十位！
#include "stdio.h"
void main(void){
double pai,nDec,tmp;
int i;
nDec=1.0/10000000000;
for(pai=0,i=1;(tmp=1.0/i)>nDec;pai+=tmp,i+=4);
for(i=3;(tmp=1.0/i)>nDec;pai-=tmp,i+=4);
printf("pai=%.10f\n",4*pai);
}
⑧ c语言求π的精度问题
算π没那么麻烦吧？？你那个问题出在类型转换上，可以统一用double，但是用double的话模运算就不能用了哦~
另外记得求和的时候先把求和的那个变量赋值成0
给你一个我写的成品
#include <stdio.h>
void main()
{
double i=1,k=1,pi=0;
for(;i<=10000;i++,k=-k)
pi=pi+(1/(2*i-1))*k;
pi=pi*4;
printf("%.8f\n",pi);
}
⑨ C语言求π，但是怎么求都是2，esp是精度。以下是定义的函数。
问题可能出现在f，f开始为初始化，可能导致f会小于eps，这样for循环将不会被执行到，自然就只执行了g=2.0*g，结果就始终为2了
⑩ C语言中如何取无限精度的pi
只能把它转变为字符串来表示了。因为无论是float还是double都会溢出的。