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

    2020-10-20 23:42:50
    实验1.2:高精度计算PI值 所用公式: 在这里插入代码片 #include <stdio.h> #include <stdlib.h> typedef struct list{ int data; struct list *next; struct list *pre; }list; list* Initlist...

    实验1.2:高精度计算PI值

    在这里插入图片描述
    所用公式:
    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct list{
        int data;
        struct list *next;
        struct list *pre;
    }list;
    
    list* Initlist()
    {
        list* head;
        head=(list*)malloc(sizeof(list));
        head->next=head->pre=head;
        return head;
    }
    list* Creatlist(list*head)
    {
        int i;
        list *p;
        p=head;
        for(i=0;i<1000;i++)
        {
            list *q=(list*)malloc(sizeof(list));
            q->data=0;
            q->pre=p;
            p->next=q;
            q->next=head;//第一次循环时此时的head和p是一个东西,目的为把链表画成一个圈
            head->pre=q;
            p=p->next;
        }
        return head;
    }
    int main()
    {
        int n,i,a,b;
        scanf("%d",&n);
        list *number,*sum;
        list *p,*q,*x;
        number=Initlist();
        sum=Initlist();
        number=Creatlist(number);
        sum=Creatlist(sum);
        number->next->data=2;//第一位储存2,即2*R(1)=2
        sum->next->data=2;//与上同理
        a=0,b=0;//分别是用来暂时存储进位和余数
        for(i=1;i<2000;i++)//循环两千次,确保精确度
        {
    
    
            p=number->pre;//做大数乘法时从链表的后方开始
            while(p!=number)//大于10则把10位的数字给b,个位数字放入data域中。
            {
                a=p->data*i+b;
                p->data=a%10;
                b=a/10;
                p=p->pre;
            }
            b=0;//清空b,为除法做准备
            p=p->next;//大数除法从链表的前方开始
            while(p!=number)//若计算出的数字为自然数,则直接放入data域;若等于0,或为小数,则要计算余数并给b。
            {
                a=p->data+b*10;
                p->data=a/(2*i+1);
                b=a%(2*i+1);
                p=p->next;
            }
            b=0;//清零
            p=number->pre;//大数加法均从末尾开始
            q=sum->pre;
            while(p!=number)//大于10进位,并储存个位数,进位数字赋给b。
            {
                a=p->data+q->data+b;
                q->data=a%10;
                b=a/10;
                p=p->pre;
                q=q->pre;
            }
        }
        printf("3.");
        x=sum->next->next;//从小数开始输出。
        for(i=0;i<n;i++)
        {
            printf("%d",x->data);
            x=x->next;
        }
        return 0;
    }
    
    

    当n=5时,PI=3.14159
    当n=500时 ,
    PI=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912

    展开全文
  • 高精度计算pi值(参考后)问题参考原理代码 问题 问题如图,高精度计算pi值用泰勒展开式计算。 参考 参考了大佬的代码后加了原理以及注释;大佬原文...

    高精度计算pi值(参考后)

    问题

    问题如图,高精度计算pi值用泰勒展开式计算。
    在这里插入图片描述

    参考

    参考了大佬的代码后加了原理以及注释;大佬原文
    https://blog.csdn.net/zhao2018/article/details/79929881?utm_source=app&app_version=4.6.0

    原理

    1.由于计算的精度会达到很多位数,而浮点型数据最多位数32或64位,无法满足需求,则只能考虑自己建立一个元素组来计算,其中有整数部分,还有很多位数的小数部分。暂时考虑用链表计算,每个节点存储一位数的值。
    2.计算时观察泰勒展开式发现表达式是将n个具有递推关系的式子Rn相加,而Rn与Rn-1关系式中有乘法除法,则考虑设计加法,乘法,除法函数。
    3.由于多位数计算加法和乘法需从最低位开始计算,而单向链表定位最低位比较困难,则考虑双向循环链表,可使p-pre从而指向最后一个结点—表示最低位的数的值
    4.分别写出各运算的算法—需考虑进位,补数等竖式计算原则
    5.循环内进行运算,运算结束后根据n的值来输出链表的前面多少个结点,从而得到最终pi的值。

    代码

    代码以及相关注释如下:

    #include <stdio.h>  
    #include <stdlib.h>  
    #define MAX 1000  
    typedef struct Node
    {
        int data;//每个结点一个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;
        printf("请输入n值(即精确到小数点后多少位)");
        scanf_s("%d", &n);
        LinkList sum, R;
        sum = (LinkList)malloc(sizeof(LNode));
        R = (LinkList)malloc(sizeof(LNode));
        Create(sum);
        Create(R);
        sum->next->data = 3;//之所以取3是因为pi是6分之pi的6倍,而R1同理也应该乘以6,才能求出pi而不是6分之pi
        R->next->data = 3;
        while (s < 2000)
        {
            top = (2 * s - 1) * (2 * s - 1);//top是Rn与Rn-1关系式当中的分子
            bottom = 8 * s * (2 * s + 1);//bottom是Rn与Rn-1关系式当中的分母
            Multiply(R, top);//每一位与top相乘
            Divide(R, bottom);//每一位与top相除
            Sum(R, sum);//将Rn与Rn-1相加
            s++;
        }//计算1999个式子相加后得到的值即为
        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;
            }//实际上以及计算出sum链表的每一位,这里n为多少,输出多少为小数点后的即取多少位精确值
        }
        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;
        }//MAX在这里确定了最终链表是1000个元素
    }//建立了一个双向循环链表,里面的结点元素全部为0-》循环链表可以使之第一次就pre从而指向尾部-》位数最小的那位-》符合多位数的运算
    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是比该位低的那一位做乘法运算时多出来的需要加到高位的,初始化时为0
            y = x / 10;//作为下一次加到高位的数
            p->data = x % 10;//本位的结果
        }
        x = (p->data) * n + y;
        y = x / 10;
        p->data = x % 10;
    }//每一位从低位到高位依次与top相乘
    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;//上一位到这一位补充的y乘以10,y初始化时为0
            p->data = x / n;//本位结果
            y = x % n;//除法得到的余数进入比本位低的那位乘以10加上去
        }
    }//每一位从高位到低位依次与bottom相除
    
    
    展开全文
  • 数据结构实验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;
    }
    
    展开全文
  • 实验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...

     

    /*#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=(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 traverse(list l)
    {
    	printf("%d.",l->next->data);
    	l=l->next;
    	list p;
    	p=l->next;
    	while(p!=NULL&&k)
    	{
    		printf("%d",p->data);
    		p=p->next;
    		k--;
    	}
    	printf("\n");
    }
    
    void SumAll(list p,list suml)
    {
        list q,sum;
    	int ret,tmp,cnt=3,num=1;
    	int sign=1;
    	while(sign)
    	{
    		q=p->next;
    		sum=suml->next;
    		ret=0;
    		while(q->next)
    		{
    			q=q->next; //q指向p的最后一位
    		}
    		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;
    		}
    		sign=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;
    				sign |= q->data;
    				sum=sum->pre;
    				q=q->pre;
    			}
    		}
    		num++;
    		cnt+=2;
    	}
    }
    
    int main()
    {
    	list p;
    	list sum1;
    	int i;
    	scanf("%d",&k);
    	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<=500;i++)
    	{
    		insert(p,0);
    		insert(sum1,0);
    	}
    	SumAll(p,suml);
    	traverse(sum1);
    	destorylist(p);
    	destorylist(sum1);
    	return 0;
    }*/
    #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 p=l,q;
        int i;
        p->next=p->pre=l;
        for(i=0;i<1000;i++)
        {
            q=(list)malloc(sizeof(node));
            q->data=0;
            p->next=q;
            q->pre=p;
            q->next=l;
            l->pre=q;
            p=q;
        }
    }
    
    void destorylist(list l)
    {
    	list p=l->next;
    	list q;
    	while (p!=l)
    	{
    		q = p->next;
    		free(p);
    		p = q;
    	}           //将头结点后逐项释放
    	free(l);   //最后释放头结点
    	l = NULL;
    }
    
    
    void traverse(list sum)
    {
        int i;
        if(k==0)
            printf("3\n");
        else
        {
            sum=sum->next;
            printf("%d.",sum->data);
            for(i=0;i<k;i++)
            {
                printf("%d",sum->next->data);
                sum=sum->next;
            }
        }
    }
    
    void Sum(list q,list sum)
    {
        list a=q->pre,b=sum->pre;
        int tmp;
        while(b!=sum)
        {
            tmp=a->data+b->data;
            b->data=tmp%10;
            b->pre->data+=tmp/10;
            a=a->pre;
            b=b->pre;
        }
    }
    
    void Multiply(list q,int n)
    {
        list a=q->pre;
        int ret=0,tmp=0;
        for(;a!=q;a=a->pre)
        {
            tmp=(a->data)*n+ret;
            ret=tmp/10;
            a->data=tmp%10;
        }
        tmp=(a->data)*n+ret;
        ret=tmp/10;
        a->data=tmp%10;
    }
    
    void Divide(list q,int n)
    {
           list a=q->next;
           int tmp=0,ret=0;
           for(;a!=q;a=a->next)
           {
               tmp=a->data+10*ret;
               a->data=tmp/n;
               ret=tmp%n;
           }
    }
    
    int main()
    {
    	list p,sum;
    	int mother,son,s=1;
    	scanf("%d",&k);
    	p=(list)malloc(sizeof(node));
    	sum=(list)malloc(sizeof(node));
    	init(p);
    	init(sum);
        p->next->data=3;
        sum->next->data=3;
        while(s<1000)
        {
            son=(2*s-1)*(2*s-1);
            mother=8*s*(2*s+1);
            Multiply(p,son);
            Divide(p,mother);
            Sum(p,sum);
            s++;
        }
    	traverse(sum);
    	destorylist(p);
    	destorylist(sum);
    	return 0;
    }

     

    展开全文
  • 在本题中,笔者限于实力,只能先将PI值进行许多次计算,再在输出时截断至所需位数。这对时间或空间来说都是一场灾难。大佬则可根据下图来确定每次所需计算次数来节省时间和空间。 代码: #include <stdio.h> ...
  • 数据结构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; ...
  • 这是数据结构第二题的题目,是让我们根据用户的需求来计算派的 这是题目的详细描述,刚看到这道题的时候,我是真的头大,完全没有思路,于是查找了一些大佬的笔记后才开始编写 这是我在写这些代码是所运用到的数学...
  • //由于取的是PI/6,计算结果为1/2,则6/2=3 headsum->next->data = 3; int a=0, b=0; // a存当前项的计算值,b存进位或余数 // 方法是计算出2000项的加和的,之后按照题目所需的n进行取相应位数 for(int i=...
  • #include <stdio.h> #include <stdlib.h> #define MAX 1000 typedef struct DuLNode{ int data; struct DuLNode *first; struct DuLNode *last; struct DuLNode *prior;...}
  • 题目描述:限制使用双向链表作储存结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。 代码如下: #...
  • 高精度计算π

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

    2021-04-01 19:23:39
    C语言计算pi1.输入代码,结果如下。2.源代码 1.输入代码,结果如下。 利用pi的级数展开公式如下: 输入一个正整数,越大、精度,比如输入10000,结果如下: 2.源代码 /* Note:Your choice is C IDE */ #...
  • 题意 用双向循环链表为存储结构解决高进度pi问题。pi值要精确到第几位,就输出到第几位。 思路 首先给出我们计算pi的理论依据 行了,从这个结构上就可以...//高精度计算PI #include <stdio.h> #include <stdl
  • PI值计算

    千次阅读 2011-10-08 01:54:40
    HDU 2179 pi值计算  先发上大数版本的程序(java水的,不想写高精度了。。) import java.math.BigDecimal; import java.math.BigInteger; import java.util.Scanner; p
  • 巴塞尔问题,也就是以下级数的和: ∑n=1∞1n2=lim⁡x→∞(112+122⋯+1n2)\sum_{n=1}^{\infty}\frac{1...其精确已经被证明是 π26\frac{\pi ^2}{6}6π2​ 现在用python编写程序从正面逼近巴塞尔问题的精确 直接计算
  • 计算圆周率 Pi (π)

    千次阅读 2004-06-25 16:39:00
    电脑可以利用级数计算出很多高精度, 有关级数的问题请参考《高等数学》,以下是比较有名的有关π的级数: 其中有些计算起来很复杂, 我们可以选用第三个, 比较简单, 并且收敛的非常快。因为计算π, 而这个公式是...
  • 大数计算器,采用迭代等算法我用它计算了上亿位的PI值://改进方向: // 1.强力优化ArrayMUL数组乘运算(当前实现了二分法和FFT算法): // a.将实数按齐偶作为复数进行傅立叶变换的算法实现,加快乘法速度 // b.实现...
  • 电脑可以利用级数计算出很多高精度, 有关级数的问题请参考《高等数学》,以下是比较有名的有关π的级数: 其中有些计算起来很复杂, 我们可以选用第三个, 比较简单, 并且收敛的非常快。因为计算π, 而这个公式...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

高精度计算pi值