精华内容
下载资源
问答
  • 高精度计算PI值

    千次阅读 2018-04-13 15:42:35
    问题描述:限制使用双向链表作存储结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。code:#include &...

    问题描述:限制使用双向链表作存储结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。

    code:

    #include <stdio.h>  
    #include <stdlib.h>  
    #define MAX 1000  
      
    typedef struct Node  
    {  
        int data;  
        struct Node *pre;  
        struct Node *next;  
    } LNode,*LinkList;  
      
    void Create(LinkList L);  
    void Sum(LinkList a,LinkList b);  
    void Multiply(LinkList a,int k);  
    void Divide(LinkList a,int k);  
      
    int main()  
    {  
        int n,i,top,bottom,s=1;  
        scanf("%d",&n);  
        LinkList sum,R;  
        sum=(LinkList)malloc(sizeof(LNode));  
        R=(LinkList)malloc(sizeof(LNode));  
        Create(sum);  
        Create(R);  
        sum->next->data=3;  
        R->next->data=3;  
        while(s<2000)  
        {  
            top = (2*s-1)*(2*s-1);  
            bottom=8*s*(2*s+1);  
            Multiply(R,top);  
            Divide(R,bottom);  
            Sum(R,sum);  
            s++;  
        }  
        if(n==0)  
        {  
            printf("3\n");  
        }  
        else  
        {  
            sum=sum->next;  
            printf("%d.",sum->data);  
            for(i=0; i<n; i++)  
            {  
                printf("%d",sum->next->data);  
                sum=sum->next;  
            }  
        }  
        printf("\n");  
        return 0;  
    }  
      
    void Create(LinkList L)  
    {  
        LinkList p=L,q;  
        int i;  
        L->next=L->pre=L;  
        for(i=0; i<MAX; i++)  
        {  
            q=(LinkList)malloc(sizeof(LNode));  
            q->data=0;  
            p->next=q;  
            q->pre=p;  
            q->next=L;  
            L->pre=q;  
            p=q;  
        }  
    }  
    void Sum(LinkList a,LinkList b)  
    {  
        LinkList p=a->pre,q=b->pre;  
        int n;  
        while(q!=b)  
        {  
            n=q->data+p->data;  
            q->data=n%10;  
            q->pre->data+=n/10;  
            q=q->pre;  
            p=p->pre;  
        }  
    }  
    void Multiply(LinkList a,int n)  
    {  
        LinkList p=a->pre;  
        int x,y=0;  
        for(; p!=a; p=p->pre)  
        {  
            x=(p->data)*n+y;  
            y=x/10;  
            p->data=x%10;  
        }  
        x=(p->data)*n+y;  
        y=x/10;  
        p->data=x%10;  
    }  
    void Divide(LinkList a,int n)  
    {  
        LinkList p=a->next;  
        int x,y=0;  
        for(; p!=a; p=p->next)  
        {  
            x=p->data+y*10;  
            p->data=x/n;  
            y=x%n;  
        }  
    }  

    展开全文
  • 数据结构28——高精度计算PI值

    千次阅读 2018-03-29 21:33:31
    题目:输入n,输出PI精确到小数点后n位的PI值。#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct node { int data; struct node*next; struct node*pre; }node,*list; int n; ...

    题目:输入n,输出PI精确到小数点后n位的PI值。

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node {
    	int data;
    	struct node*next;
    	struct node*pre;
    }node,*list;
    
    int n;
    
    void init(list &l)
    {
        list tail = l, p;
    	int i = 0;
    	p=(list)malloc(sizeof(node));
    	tail->next = p;
    	p->pre = tail;
    	tail = p;
    	p->data = 2;
    	tail->next = NULL;
    }
    
    void destorylist(list &l)
    {
    	list p=l->next;
    	list q;
    	while (p->next)
    	{
    		q = p->next;
    		free(p);
    		p = q;
    	}
    	free(l);
    	l = NULL;
    }
    void insert(list &l, int data)
    {
    	list p = l;
    	if(p == NULL)
    	{
    		return;
    	}
    	else
    	{
    		while (p->next)  
    			p = p->next;
    		list temp = (list)malloc(sizeof(node));
    		p->next = temp; 
    		temp->data = data;
    		temp->pre = p;
    		temp->next = NULL;		
    	}
    }
    
    void tran(list l)
    {
    	printf("%d.",l->next->data);
    	l=l->next;
    	list p;
    	p=l->next;
    	while(p!=NULL&&n)
    	{
    		printf("%d",p->data);
    		p=p->next;
    		n--;
    	}
    	printf("\n");
    }
    
    int main()
    {	
    	list p,sum1;
    	int i;
    	
    	scanf("%d",&n);
    	p=(list)malloc(sizeof(node));
    	sum1=(list)malloc(sizeof(node));
    	p->next = NULL;
    	sum1->next=NULL;
    	p->pre = NULL;
    	sum1->pre=NULL;
    	
    	init(p);
    	init(sum1);
    	
    	for(i=1;i<=1000;i++)
    	{
    		insert(p,0);
    		insert(sum1,0);
    	}
    	list q,sum;
    	int ret,tmp,cnt=3,num=1;
    	int flag=1;
    	while(flag)
    	{			
    		q=p->next;
    		sum=sum1->next;
    		ret=0;
    		while(q->next)
    		{
    			q=q->next;			
    		}
    		while (q)
    		{
    			tmp=q->data*num+ret;
    			q->data=tmp%10;
    			ret=tmp/10;
    			if(q->pre==NULL)break;
    			else
    			{
    				q=q->pre;
    			}
    		}
    		
    		ret=0;
    		q=p->next;
    		while (q)
    		{
    			tmp=q->data+ret*10;
    			q->data=tmp/cnt;
    			ret=tmp%cnt;
    			if(q->next==NULL)break;
    			else
    			{
    				q=q->next;
    			}
    		}
    
    		q=p->next;
    		sum=sum1->next;
    		while(q->next&&sum->next)
    		{
    			q=q->next;
    			sum=sum->next;
    		}
    		flag=0;
    		while (q&&sum)
    		{
    			
    			tmp=sum->data+q->data ;
    			sum->data=tmp%10;
    			if(sum->pre==NULL||q->pre==NULL)
    			{
    				break;
    			}
    			else
    			{
    				sum->pre->data+=tmp/10;
    				flag |= q->data;
    				sum=sum->pre;
    				q=q->pre;
    			}
    			
    		}
    		num++;
    		cnt+=2;
    	}
    	tran(sum1);
    	destorylist(p);
    	destorylist(sum1);
    	return 0;
    }

    展开全文
  • 数据结构实验1.2:高精度计算PI值

    千次阅读 2020-05-31 20:37:57
    //高精度计算PI #include <stdio.h> #include <stdlib.h> #define max 500 typedef struct Node{ int data; struct Node *next,*pre; }LHead,*LHeadPtr,Node,*NodePtr; void List_Init(LHeadPtr L)...

    在这里插入图片描述

    //高精度计算PI
    #include <stdio.h>
    #include <stdlib.h>
    
    #define max 500
    
    typedef struct Node{
        int data;
        struct Node *next,*pre;
    }LHead,*LHeadPtr,Node,*NodePtr;
    
    void List_Init(LHeadPtr L){
        L->data = 2;
        L->next = L;
        L->pre = L;
        NodePtr p,q;
        q = L;
        for(int i = 1;i < max;i++)
        {
            p = (NodePtr)malloc(sizeof(Node));
            p->data = 0;
            
            p->next = q->next;
            p->pre = q;
            q->next->pre = p;
            q->next = p;
        }
    
    }
    
    void M_D(LHeadPtr L,int zi,int mu){
        NodePtr p;
        p = L->pre;
        //乘法
        int c,d=0;
        for(;p != L;p=p->pre)
        {
            c = p->data * zi + d;
            p->data = c % 10;
            d = c / 10;
        }
        p->data +=d;
        //除法
        d = 0;
        p = L;
        while(1)
        {
            c = p->data + d * 10;
            p->data = c / mu;
            d = c % mu;
            p = p->next;
            if(p == L)
            break;
        }
    }
    
    void List_Add(LHeadPtr L1,LHeadPtr L2){//加法
        NodePtr p,q;
        p = L1->pre;
        q = L2->pre;
        int c,d=0;
        while(1)
        {
            c = p->data + q->data + d;
            p->data = c%10;
            d = c/10;
            
            p=p->pre;
            q=q->pre;
            if(p == L1->pre)
            break;
        }
    }
    
    int main(){
        LHeadPtr s,m;
        s = (LHeadPtr)malloc(sizeof(LHead));
        m = (LHeadPtr)malloc(sizeof(LHead));
        List_Init(s);
        List_Init(m);
    
        int i = 1,j=0;
        while(i<2000)
        {
            j = i*2+1;
            M_D(m,i,j);
            List_Add(s,m);
            i++;
        }
        
        int n;
        scanf("%d",&n);
        printf("%d.",s->data);
        NodePtr p = s->next;
        for(int i = 0;i < n;i++)
        {
            printf("%d",p->data);
            p=p->next;
        }
        printf("\n");
        return 0;
    }
    
    展开全文
  • 高精度计算pi(C语言)

    千次阅读 2021-03-26 14:29:58
    i++,t=t+2){//根据数学的知识,算的次数越多越精确 //i同时承担计数和做乘数的任务 //先计算乘法(即公式中R(n)*n) node* p3 = numtail; ret=0; while(p3) { temp = p3 -> date * i + ret; p3 -> date = temp%10; ...

    题目

    在这里插入图片描述

    解题入手

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct node{
     int date;
     struct node* pre;
     struct node* next;
    }node;
    
    void insert(node* list,int date){
    //尾插法向链表中添加元素
     node* p = list;
     if(p==NULL){
      return;
     }
     else{
      while(p->next){
       p = p -> next;
      }
       node* pnew=(node*)malloc(sizeof(node));
       pnew -> date = date;
       p -> next = pnew;
       pnew-> pre =p;
       pnew -> next = NULL;
     }
    }
    
    void tranverselist(node* list,int n){
    //遍历链表并输出指定位数的小数
     node* p = list;
     p=p->next;
     printf("%d.",p->date);
     int i;
     p=p->next;
     for(i=0;i<n;i++){
      printf("%d",p->date);
      if(p->next){
       p=p->next;
      }
     }
     printf("\n");
    }
    
    int main()
    {
        node *num,*sum;//num为每次相加的 R(n); um最终的值约等于 Π;
        num=(node*)malloc(sizeof(node));
         sum=(node*)malloc(sizeof(node));
        num -> pre = NULL;
       sum -> pre = NULL;
        num -> next = NULL;
        sum -> next = NULL;
    
       int n;
       scanf("%d",&n); //n为题目要求输出的的Π的小数位数;
        int i;
     for(i=0;i<520;i++){//补够位数
      insert(num,0);
      insert(sum,0);
     }
     node* p1 = num -> next;
     node* p2 = sum -> next;
      //使两个链表除头节点外第一个节点的数据为2
     p1->date=2;
     p2->date=2;
      //指向num,和sum的尾节点
     while(p1->next){
      p1=p1->next;
     }
     node* numtail = p1;
     while(p2->next){
      p2=p2->next;
     }
     node* sumtail = p2;
     //开始运算;
     int temp = 0;//计算过程中产生的临时数据
     int ret = 0; //计算过程中产生的借位or进位
     int t;//计算时有规律出现的除数 (2n+1)
     for(i=1,t=3;i<10000;i++,t=t+2){//根据数学的知识,算的次数越多越精确
       //i同时承担计数和做乘数的任务
       //先计算乘法(即公式中R(n)*n)
       node* p3 = numtail;
       ret=0;
       while(p3) {
        temp = p3 -> date * i + ret;
        p3 -> date = temp%10;
        ret = temp/10;
        p3 = p3 -> pre;
       }
       ret = 0;
       p3 = num -> next;
       //计算除法 (即公式中的R(n)*n/(2*n+1))
       while(p3){
         temp = p3 -> date + ret*10;
         ret = temp % t;
        p3 -> date = temp/t;
        p3=p3->next;
       }
       ret = 0;
       node*  p4 = sumtail;
       p3 = numtail;
       //将得到的R(n)的值加入到结果中
       while(p3&&p4){
        temp = p3 -> date + p4->date +ret ;
        ret = temp/10;
        p4->date=temp%10;
        p3=p3->pre;
        p4=p4->pre;
       }
     }
     tranverselist(sum,n);
     return 0;
    }
    
    
    
    
    展开全文
  • 实验1.2 高精度计算PI值

    千次阅读 2019-06-29 11:18:14
    /*#include<stdio.h> #include<stdlib.h> int k; typedef struct node { int data; struct node*next; struct node*pre; }node,*list; void init(list l) { list tail = l, p;... p=(li...
  • 高精度计算π

    千次阅读 2018-03-23 18:04:33
    限制使用双向链表作存储结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。 Input 输入的一个正整数n ...
  • C语言求高精度PI

    万次阅读 2012-08-30 10:19:22
    如下代码能求解出高精度PI值 #include #include long a=10000,b,c=2800,d,e,f[2801],g; int main() { for(;b-c;) f[b++]=a/5; for(;d=0,g=c*2;c-=14,printf("%.4ld",e+d/a),e=d%a) //原代码为%.4d,...
  • Matlab可调节精度基于几何概率计算pi

    千次阅读 2019-04-03 10:09:40
    问题描述 写一个Matlab函数,满足: 输入:所需的精度 输出:该精度下的pi 使用基于下述几何概率的算法: 单位正方形中,有四分之一个...该函数应重复计算命中和失误的次数,重复不得少于1000次 ,并且多个pi的...
  • 高精度计算Π的(C语言)

    千次阅读 2020-09-16 21:37:16
    限制使用双向链表作存储结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。 输入5 输出3.14159 思路...
  • #define M_PI 3.14159265358979323846 转载于:https://www.cnblogs.com/xingzhensun/p/9723241.html
  • 圆周率PI高精度计算(C/C++)

    千次阅读 2013-01-07 19:13:40
    某次碰到pi,想用编程打印出它的比较多的有效位(至少比背的要多)。 开始考虑到 pi/4 = arctan(1) arctan(x)展成多项式 arctan(x) = (1/1!)x - (1/3)(x^3) + (1/5)(x^5) - .... 所以有 pi/4 = 1 - 1/3 + 1/5 - 1...
  • C语言计算pi1/2

    2021-04-01 19:23:39
    C语言计算pi1.输入代码,结果如下。2.源代码 1.输入代码,结果如下。 利用pi的级数展开公式如下: 输入一个正整数,越大、精度,比如输入10000,结果如下: 2.源代码 /* Note:Your choice is C IDE */ #...
  • 搭建MPI并行计算环境,利用课件中计算PI的公式,计算PI值,n分别使用100、1000、10000计算结果。要求写出实验报告,并对实验结果进行分析,分析n值对PI精度的影响,并行进程个数对计算速度的影响。 实验内容及代码...
  • 计算PI值

    千次阅读 2017-03-13 22:15:42
    计算PI值 一个PI值计算的算法。 分析该算法。 实现该算法。 算法:PI/2=1/3 + 1/3 * 2/5 + 1/3 * 2/5 * 3/7 + …….+ 1/3* ……* n/(n+1) 分析:如果直接写成程序的花很难,既要算乘法又要算除法还要算加法还要保证...
  • python输出指定精度的圆周率pi

    万次阅读 2019-05-14 16:04:08
    这样就得到了pi的近似3.141592653589793,要得到后面的小数, 不是直接可以简单粗暴的乘以10的指数 import math val = math.pi * 100000000000000000 print(val) 但是当val的小数部分都变成整数1415926535...
  • 然后她就给我发了她写的一段代码,问题很简单就是计算PI。结果正确,但是题库端给她的结果是运行超时,这个就是她写的。 #include <stdio.h> #include <math.h> int main { double n,i,j,PI; j=1; n...
  • PI值计算

    千次阅读 2011-10-08 01:54:40
    HDU 2179 pi值计算  先发上大数版本的程序(java水的,不想写高精度了。。) import java.math.BigDecimal; import java.math.BigInteger; import java.util.Scanner; p
  • 使用MapReduce计算Pi

    千次阅读 2017-03-11 23:48:29
    统计(0.5,0.5)为圆心的单位圆中落点占总落点数的百分比,即可算出单位圆的面积Pi/4,然后乘以4即得到Pi的近似。从输入文件中读入一行内容。每一行都是一个数字,代表随机投掷那么多点来估算Pi。在Mapper中则...
  • 计算PI(π)的几种方法

    万次阅读 多人点赞 2018-03-13 21:15:23
    点的比值求PI。 由于图形的对称性,我们靠考虑该图的四分之一部分。 假定一点能够均匀地扔到一个正方形中,计算落入其中的点个数。通过计数其中落入内切圆的点的个数; 如果一共投入N个点,其中有M个落入圆中...
  • pi的近似

    千次阅读 2020-02-16 16:08:49
    pi的近似 输入精度 e,使用格雷戈里公式求 π 的近似,精确到最后一项的绝对值小于 e. 格雷戈里公式如下: π/4​ = 1 − 1/3 + 1/5 - 1/7...# 请根据 e 计算 pi 的近似 x=-1 n=2 result=1 while(1/(2*n-3)&...
  • 利用Python的特殊功能,简单实现万位高精度圆周率计算。 啥也别说了,直接给代码: # -*- coding: UTF-8 -*- # calculating PI with a simple series # Author: Idealguy,Shanghai,2018 # pi=2*(1+1/3+1/3*2/5+...
  • 使用c++计算高精度的π的,其实就是一个数学的方法向c++语言转化的过程,下面将会展示: (1)选择计算公式:选取收敛速度快的且容易朝着的计算公式是首要的一环。我们选用: π/2=1+1/3+1/3*2/5+1/3*2/5*3/7……+...
  • 求解圆周率PI的近似

    千次阅读 2019-01-29 16:01:04
    求圆周率PI的近似,直到发现某一项的绝对值小于10^(-6)为止(该项不累加)。 要求输出的结果总宽度占10位,其中小数部分为8位。 程序中使用浮点型数据时,请定义为双精度double类型。 如果需要计算绝对值,可以...
  • PI的近似(近似算法)

    千次阅读 2021-06-11 08:46:05
    题目 求PI的近似值 (30 分) 用正多边形逼近法求π的近似值。 用圆内接正多边形的边长和半径之间的关系,不断将边数翻倍并求出边长,重复这一过程,正多边形的边长就逐渐逼近圆的...圆内接正多边形的边数n和PI值,PI的
  • 又去看了一下几个圆周率的算法,挑了莱布尼茨迭代公式:pi/4=1-1/3+1/5-1/7+1/9…… 求出来的结果是(100位小数): 3....
  • 精度pi计算 汇编实现

    千次阅读 2010-11-28 20:47:00
    vier Gourdon坛子上的... 我写这个程序,其效率不是主要学习的东东,主要是体会一下多精度计算的一种思想,用多字节模拟大数据,当然有些3两行的代码或许也可计算pi 但很难体会不到这一点。 像
  • 巴塞尔问题,也就是以下级数的和: ∑n=1∞1n2=lim⁡x→∞(112+122⋯+1n2)\sum_{n=1}^{\infty}\frac{1...其精确已经被证明是 π26\frac{\pi ^2}{6}6π2​ 现在用python编写程序从正面逼近巴塞尔问题的精确 直接计算

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,896
精华内容 8,358
关键字:

高精度计算pi值