多线程编程计算 π 的值

最新推荐文章于 2022-04-24 12:53:39 发布
最新推荐文章于 2022-04-24 12:53:39 发布
阅读量1.4k 收藏 6
点赞数
分类专栏： C/C++ 关于算法那些事 文章标签： c++ c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Prototype___/article/details/122003969
版权

一、实验内容

使用 For 循环制导语句计算π 的值

二、运行结果

1、代码实现：

#include <stdio.h>
#include <omp.h>
#include <cmath>
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include "PrecisionNum.cpp"
#include "stdint.h"


void calculatePi3() {
    time_t start=clock();
    long step=1000;
    PrecisionNum bigstep(step),pi(0),dx,four(4),two(2);
    PrecisionNum one(1);
    PrecisionNum x2;
    dx=dx.div(one,bigstep);
    for(int i;i<step;++i) {
        x2=i+0.5;
        x2=x2/step;
        x2=x2*x2;
        ++x2;
        x2=x2.div(four,x2);
        x2=x2.mul(x2,dx);
        pi=pi+x2;
    }
    time_t finish=clock();
    cout<<"spend time:"<<double(finish-start)/CLOCKS_PER_SEC<<"s";
    cout<<"    CalculatePi: "<<endl;
    pi.showAll();
}

int main(int argc,char* argv[]) {
    time_t start=clock();
    cout<<"start clock:"<<start<<endl;

    calculatePi3();
    time_t finish=clock();
    cout<<"finish clock:"<<finish<<endl;
    cout<<"total time:"<<double(finish-start)/CLOCKS_PER_SEC<<"s"<<endl;
    return 0;
}

PrecisionNum.cpp

// Created by VULAN on 2021/12/17.
//

#include <iostream>
#include <string>

using namespace std;
class PrecisionNum {
    // data type : left[0...511].left[512...2047]
private:
    int left[2560], leftpos=0, rightpos=0, MAX_SIZE=2560; ; // 限定小数有效位数
public:
    bool positive=true;
    PrecisionNum(double a=0) {
        if(a<0) {  a=-a;   positive=false; }
        int i=0; // 数组下标i
        long long num=(long long) a;
        a-=num;  // 小数
        for(i=0;i<MAX_SIZE;++i) left[i]=0;
        i=511;
        while(num>0) {
            left[i]=num%10;
            int tmp=left[i];
            num=num/10;
            --i;
        }
        // 小数部分
        i=512;
        while(a>0 && i<MAX_SIZE) {
            left[i]= (int)(a*10);
            a=a*10-left[i];
            ++i;
        }
        length();
    }

    PrecisionNum(string a) {
        int len=a.length();
        int ipos=len;
        for(int i=0;i<2560;++i) {
            if(a[i]=='.') {
                ipos=i;
            }
        }
        for(int i=ipos-1;i>=0;--i) {
            left[i]=a[i]-'0';
        }
        for(int i=ipos+1;i<len;++i) {
            left[i]=a[i]-'0';
        }
    }

    PrecisionNum operator++(){
        this->left[511]++;
        for(int i=511;i>0;--i) {
            if(left[i]>9) {
                left[i-1]+=left[i]%10;
                left[i]=left[i]/10;
            }
        }
        return *this;
    }

    PrecisionNum operator+(PrecisionNum &b) {
        PrecisionNum ret;
        int i=0;
        int maxlen=b.rightpos, minleftpos=b.leftpos;
        if(rightpos > maxlen) maxlen=rightpos;
        if(leftpos<minleftpos) minleftpos=leftpos;
        --minleftpos;
        for(i=maxlen;i>=minleftpos;--i) {
            ret.left[i]+=this->left[i]+b.left[i];
            if(ret.left[i]>9) {
                if(i>0) {
                    ret.left[i - 1]+=ret.left[i]/10;
                    ret.left[i]=ret.left[i]%10;
                }
            }
        }
        ret.length();
        return ret;
    }

    PrecisionNum operator+(double a) {
        PrecisionNum b(a);
        return b.add(*this,b);
    }

    PrecisionNum operator-(double a) {
        PrecisionNum ba(a);
        return sub(*this,ba);
    }

    PrecisionNum operator-(PrecisionNum a) {
        return sub(*this,a);
    }

    PrecisionNum operator*(double a) {
        PrecisionNum b(a);
        return this->mul(*this,b);
    }

    PrecisionNum operator*(PrecisionNum a){
        return this->mul(*this,a);
    }

    PrecisionNum operator/(double a) {
        PrecisionNum ba(a);
        return div(*this,ba);
    }

    PrecisionNum operator/(PrecisionNum a) {
        return div(*this,a);
    }

    PrecisionNum add(PrecisionNum a, PrecisionNum b) {
        PrecisionNum ret;
        int i=0;
        if(a.positive && b.positive==false) {
            b.positive=true;
            ret=sub(a,b);
            b.positive=false;
            return ret;
        }
        if(a.positive==false && b.positive==true) {
            a.positive=true;
            ret=sub(b,a);
            a.positive=false;
            return ret;
        }
        if(a.positive==false && b.positive==false) ret.positive=false;
        int maxRight=b.rightpos, minLeft=b.leftpos;
        if(a.rightpos > maxRight) maxRight=a.rightpos;
        if(a.leftpos<minLeft) minLeft=a.leftpos;
        if(minLeft > 0) --minLeft;
        for(i=maxRight;i>=minLeft;--i) {
            ret.left[i]+=a.left[i]+b.left[i];
            if(ret.left[i]>9) {
                if(i>0) {
                    ret.left[i - 1]+=ret.left[i]/10;
                    ret.left[i]=ret.left[i]%10;
                }
            }
        }
        ret.length();
        return ret;
    }

    PrecisionNum sub(PrecisionNum a ,PrecisionNum b) {
        PrecisionNum ret;   // 待完成
        string sa=a.toString2(),sb=b.toString2(),sr;
        if(a.positive==false && b.positive) {
            ret=a;
            ret.positive=true;
            ret=ret+b;
            ret.positive=false;
        }
        else if(a.positive==false && b.positive==false) {
            a.positive=true;
            b.positive=true;
            if(compare2(a,b)) { //比较a b的绝对值
                ret=sub(a,b);
                ret.positive=false;
            } else {
                ret=sub(b,a);
            }
            a.positive=false;
            b.positive=false;
        }
        else if(a.positive && b.positive==false) {
            b.positive=true;
            ret=add(a,b);
            b.positive=false;
        }
        else if(a.positive && b.positive) {
            if(compare2(a,b)) {
                int maxRight=a.rightpos>b.rightpos?a.rightpos:b.rightpos;
                int minLeft=a.leftpos;
                if(minLeft>0) --minLeft;
                for(;maxRight>=minLeft;--maxRight) {
                    if(a.left[maxRight]<b.left[maxRight]) {
                        a.left[maxRight-1]--;
                        ret.left[maxRight]+=a.left[maxRight]+10-b.left[maxRight];
                    }else ret.left[maxRight]+=a.left[maxRight]-b.left[maxRight];
//                    sr=ret.toString2();
                }
            } else {
                ret=sub(b,a);
                ret.positive=false;
            }
        }
        ret.length();
        return ret;
    }

    PrecisionNum div(double na,double nb) {
        // 不考虑负数的情况, d 是b的段长, j 是商的第一位位置
        PrecisionNum a(na), b(nb);
        return div(a,b);
    }

    PrecisionNum div(PrecisionNum a,PrecisionNum &b) {
        // 不考虑负数的情况, d 是b的段长, j 是商的第一位位置
        PrecisionNum ret;
        if(b.isZero()) return ret;
//        string sa=a.toString2(), sb=b.toString2() ;
        a.getpos(); b.getpos();    //  对于0.000123 的情况更新 pos
        int d=b.rightpos-b.leftpos+1;
        if(d>(MAX_SIZE>>1)) d=(MAX_SIZE>>1);
        int j=511-((512-a.leftpos)-(512-b.leftpos)); // a与b同段长,j的位置
        int starta=0, enda=0;
        starta=a.leftpos;
        enda=starta+d-1; // a与b同段长比较, enda的位置不一定是rightpos
        for(;j<2000 && a.leftpos<= a.rightpos;) {
            if(enda>=MAX_SIZE) enda=MAX_SIZE-1;
            if(!compare(a,b,starta,enda,b.leftpos,b.rightpos)) {
                ++j; // 考虑a与b同段长的片段，如果a<b，那么商的位置j后移一位，同时++enda
                ++enda;
                if(enda>=MAX_SIZE) enda=MAX_SIZE-1;
            }
            //sa=a.toString2();
            int ia=enda, ib=b.rightpos;  // 进入while前，由getpos更新的starta位置的值一定不为0
            while(compare(a,b,starta,enda,b.leftpos,b.rightpos)) {
                // 计算单个j位的商，减到a片段小于b为止
                //sa=a.toString2();
                for (ia=enda,ib=b.rightpos ; ia >= starta; --ia, --ib) {
                    if (a.left[ia] < b.left[ib]) { // 如果ia位置的数<ib位置的数,向前借位，相减
                        a.left[ia-1]--;
                        a.left[ia] = a.left[ia] + 10 - b.left[ib];
                    } else a.left[ia] -= b.left[ib];
                }
                //sa=a.toString2();
                ++ret.left[j];
                //sb=ret.toString2();
                //情况1：a片段=0123，b=234，如果starta位置的值为0，starta后移，j位置暂时不变,
                //情况2：a片段与b长度相同，starta位置为0，starta位后移，则下次循环退出,j位置要变
                if (a.left[starta] == 0) ++starta;
            }
            if(a.isZero()) break;
            while(a.left[starta]==0) ++starta;
            // enda与j的位置实际相同,compare同时更新j与enda;
            while(!compare(a,b,starta,enda,b.leftpos,b.rightpos)) {
                ++j; // 考虑a与b同段长的片段，如果a<b，那么商的位置j后移一位，同时++enda
                ++enda;
                if(enda>=MAX_SIZE) enda=MAX_SIZE-1;
            }
//            sa=a.toString2();
            a.getpos();   // 退出while循环后，一定更新j的位置, 更新a.leftpos与endpos,
        }
        ret.length();
        return ret;
    }

    PrecisionNum mul(PrecisionNum &a, PrecisionNum &b) {
        // 不考虑负数
        PrecisionNum ret;
        int k=b.rightpos-511+a.rightpos;  // 最后一位积的位置，小数点后有几位加几，最后加上511
        for(int i=b.rightpos,m=0;i>=b.leftpos;--i,++m) { //从b的最后一位开始，依次乘a的每一位，存于ret
            k=b.rightpos-511+a.rightpos-m;  // b每一位乘完一轮，m+1,
            for(int j=a.rightpos;j>=a.leftpos;--j,--k) {
                ret.left[k]+=a.left[j]*b.left[i];
                if(ret.left[k]>9) {
                    ret.left[k-1]+=ret.left[k]/10;
                    ret.left[k]=ret.left[k]%10;
                }
            }
        }
        ret.length();
        if(ret.left[ret.leftpos]>9) {
            ret.left[leftpos-1]=ret.left[ret.leftpos]/10;
            ret.left[ret.leftpos]=ret.left[ret.leftpos]%10;
            ret.length();
        }
        return ret;
    }

    PrecisionNum pow(double x, long long k) {
        // 只计算非负数的整数次幂
        PrecisionNum ret(1);
        PrecisionNum a(x);
        if(k==0) return ret;
        for(long long  i=0;i<k;++i) {
            ret=ret.mul(ret,a);
        }
        return ret;
    }

    PrecisionNum pow(PrecisionNum &a, PrecisionNum &k) {
        // 只计算非负数的整数次幂
        PrecisionNum ret(1);
        PrecisionNum i(0);
        if(k.isZero()) return ret;
//        string sa,sb,sk;
        for(;i<k; i=i+1) {
            ret=ret.mul(ret,a);
//            sa=i.toString2(),sb=ret.toString2(),sk=k.toString2();
        }
        return ret;
    }

    string toString2() {
        int i=0;
        string s="";
        int starti;
        for(starti=0;starti<511;++starti) if(left[starti] !=0) break;
        for(i=starti;i<512;++i) {
            s.append(to_string(left[i])); }
        int endi;
        for(endi=1536;endi>511;--endi) if(left[endi] != 0) break;
        if(endi==511)  return s;
        s.append(".");
        for(i=512;i<=endi;++i) s.append(to_string(left[i]));
        return s;
    }

    void length() {
        int i;
        for(i=0;i<511;++i) if(this->left[i]>0) break;
        this->leftpos=i;
        for(i=MAX_SIZE-1;i>511;--i) if(this->left[i]>0) break;
        this->rightpos=i;
    }

    bool isZero() {
        for(int i=0;i<MAX_SIZE;++i) {
            if (left[i] > 0) return false;
        }
        return true;
    }

    void getpos() {
        int i;
        for(i=0;i<MAX_SIZE;++i) if(this->left[i]>0) break;
        this->leftpos=i;
        for(i=MAX_SIZE-1;i>0;--i) if(this->left[i]>0) break;
        this->rightpos=i;
    }

    bool compare(PrecisionNum &a, PrecisionNum &b, int starta=0, int enda=1999, int startb=0, int endb=1999) {
        if(enda>=MAX_SIZE) enda=MAX_SIZE-1;
        if(enda-starta > endb-startb) {
            // 1234:123的情况与 0123:234的情况
            if(a.left[starta] != 0) return true;
            starta++;
        }
        if(enda-starta < endb-startb) return false;
        while(a.left[starta]==b.left[startb]) {
            ++starta;
            ++startb;
            if(starta>enda) return true;
        }
        return a.left[starta] >= b.left[startb];
    }

    bool operator<(PrecisionNum &b) {
        if(this->leftpos != b.leftpos) return this->leftpos >b.leftpos;
        int maxpos=this->rightpos;
        if(b.rightpos>maxpos) maxpos=b.rightpos;
        int i;
        for(i=b.leftpos;i<=maxpos;++i) {
            if(this->left[i] != b.left[i]) break;
        }
        return this->left[i] < b.left[i];
    }

    bool operator>(PrecisionNum &b) {
        if(this->leftpos != b.leftpos) return this->leftpos <b.leftpos;
        int maxpos=this->rightpos;
        if(b.rightpos>maxpos) maxpos=b.rightpos;
        int i;
        for(i=b.leftpos;i<=maxpos;++i) {
            if(this->left[i] != b.left[i]) break;
        }
        return this->left[i] > b.left[i];
    }

    bool compare2(PrecisionNum &a , PrecisionNum &b){
        if(a.leftpos != b.leftpos) return a.leftpos<b.leftpos;
        int maxpos=b.rightpos;
        if(a.rightpos>maxpos) maxpos=a.rightpos;
        for(int i=a.leftpos;i<=maxpos;++i) {
            if(a.left[i] != b.left[i]) return a.left[i]>b.left[i];
        }
        return false;
    }

    void show2() {
        int i=0;
        string s="";
        if(!this->positive) s.append("-");
        int starti;
        for(starti=0;starti<511;++starti) if(left[starti] !=0) break;
        for(i=starti;i<512;++i) {
            s.append(to_string(left[i])); }
        int endi;
        for(endi=560;endi>511;--endi) if(left[endi] != 0) break;
        if(endi==511) {
            cout<<s<<endl;
            return; }
        s.append(".");
        for(i=512;i<=endi;++i) s.append(to_string(left[i]));
        cout<<s<<endl;
    }

    void show() {
        string s;
        if(!this->positive) s.append("-");
        for(int i=500;i<512;++i) s.append(to_string(left[i]));
        s.append(".");
        for(int i=512;i<560;++i) s.append(to_string(left[i]));
        cout<<s<<endl;
    }

    void showAll() {
        string s="";
        if(!this->positive) s.append("-");
        for(int i=leftpos;i<512;++i) {
            s.append(to_string(left[i])); }
        if(rightpos==511) {
            cout<<s<<endl;
            return; }
        s.append(".");
        for(int i=512;i<=1536;++i) s.append(to_string(left[i]));
        cout<<s<<endl;
    }

    int numAt(int i) {
        cout<<left[i]<<endl;
        return left[i];
    }
};

2、运行结果截图

calcPI

三、实验分析总结

运行结果显示，串行的计算时间比并行的计算时间短。可能是因为分割的小矩形的数量不够大所导致的。就像人们出安全通道一样，如果人数较多的话，那么大家抢着走，显然出去的速度是很慢的，如果大家排队，井然有序的出，那么效率显然会提高很多的。

极客范儿
关注
专栏目录
南京邮电大学操作系统——实验一(附加)：利用多线程计算Π值
weixin_42559271的博客
10-08 2414
文章目录实验环境实验记录第一步：单次计算π\piπ值第二步：多次计算π\piπ值数据处理及分析关于rand和rand_s函数的两个小实验 实验环境 Windows10 Ubuntu 18.04 VisualCode 实验记录 第一步：单次计算π\piπ值 算法如下： #include<stdio.h> #include<sys/types.h> #include<unistd.h> #include<stdlib.h> #include<time.h
linux多线程编程实现圆周率,linux环境下使用Monte Carlo计算π
weixin_39670849的博客
05-08 1165
1 实验题目计算π的一个有趣方法是使用一个称为Monte Carlo的技术，这种技术涉及随机。该技术工作如下：假设有一个圆，它内嵌一个正方形，如下图所示。首先，通过(x,y)坐标生成一系列的随机点。这些点应在正方形内。在这些随机产生的点中，有的会落在圆内。接着，根据下面公式，估算π。π= 4✖️(圆内的点数)/(总点数) (1)请编写一个多线程版的算法，它创建一组子线程，每个子线程产生一组随机点，...
通过多线程计算PI的值
Y734493585的博客
07-28 5916
通过多线程计算PI的值 1.PI公式: PI=4*(1-1/3+1/5-1/7+…1/(n*2-1)) 2.多线程计算思路： 通过将PI的计算分为n个部分，分配到n个线程上进行计算，再将最后的结果进行求和。 3.计算步骤及原理： 设将PI的计算分为n个线程，共计算公式的前m次。 将一加一减固定为一个基本单位。即： （1-1/3）+（1/5-1/7）+…+(1/(2n-3)+1/(n*2-1)),...
多线程计算pi（精确到多位）
04-09
多线程计算pi（精确到多位），在linux操作系统下。
多线程求PI
爱学习，爱编程
04-30 1348
<br /><br /> <br /> <br />工程名:RollingCastPI<br />类型:基于对话框的MFC程序<br />编译器:VC++ 6.0<br />功能:主线程进行控制后台线程  开始/暂停/继续/停止  计算输出PI,控制输出速度,位数. <br />源文件:<br /> <br />// stdafx.h : include file for standard system include files,<br />//  or project specific include
多线程 pi计算
05-21
使用随机数来计算pi值，使用多线程
C++ 多线程求PI
11-15
C++ 多线程求PI，里面有word文档 写的是思路
多线程初体验——使用2个线程根据莱布尼兹级数计算PI、多线程排序
Alkali!的博客
04-24 611
2022.04.24 job7/pi1.c: 使用2个线程根据莱布尼兹级数计算PI 要求 莱布尼兹级数公式: 1 - 1/3 + 1/5 - 1/7 + 1/9 - … = PI/4 主线程创建1个辅助线程 主线程计算级数的前半部分 辅助线程计算级数的后半部分 主线程等待辅助线程运行結束后,将前半部分和后半部分相加 代码 #include<stdio.h> #include<pthread.h> #define NUMBER 1000000 double worker_res
Linux环境下多线程计算&pi;值的方法
pi.c是一个C语言源代码文件，其内容应该包含了用于在Linux环境下通过多线程算法计算&pi;值的程序代码。多线程求&pi;的算法通常涉及将&pi;的计算过程分解为可以并行处理的多个小任务。一个可能的策略是将积分区间分成若干段...
pthread多线程求pi,linux多线程pthread,C,C++
09-10
在IT领域，多线程是一种常见且强大的编程技术，它允许多个任务同时执行，以提高程序的效率和响应速度。在Linux系统中，`pthread`库是C和C++编程语言实现多线程的标准接口。本文将深入探讨标题和描述中提到的...
多线程计算pi值
05-06
多线程计算pi值，运行与编译在linux系统下。
c语言多线程计算PI
06-07
并行计算中的多线程计算PI
多线程计算pi
05-25
多线程计算pi，并且做性能分析。单线程与多线程对比 计算量相同，线程数不同 例如，N取1000,000，测试使用1、2、3、4……个线程时所需要的时间。 线程数相同，计算量不同 例如，只考察单线程和双线程的性能对比，N分别取不同的数值。
pthread多线程计算pi
06-16
读入第一个参数为线程数，第二个参数为N，积分法计算pi，C+pthread实现，附结果比较表
多线程计算pi，并比较性能
03-24
这个程序是在并行计算课上写的，利用posix多线程计算pi，运行环境是linux，编程语言：ANTI C。
多线程求π
VON
03-20 1890
之前说到过 python 的多线程求 π 问题，但当时并没有贴出代码来。因为确实是之前自己写的那个程序最后结果一直不对，明明逻辑语句都没问题了。 但恰恰是我没有注意到一点，多线程的同步问题。那个求最后总数 N 的值，如果没有进行同步锁的话，那么实际情况将会导致 N 的数量变少。就是因为一个线程未完成另一个线程突然的完成或者一起完成，我是这样认为的，总之一定会导致表面上的 N 大于实际未同步相加的
Linux多线程计算Pi函数（互斥没起作用？？？）
夏菠
03-27 3027
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <sys/time.h>pthread_mutex_t mutexsum; #define thread_count 4 double sum;void* start_thread(void *rank);void* start_thread(void *ra
【MFC】多线程计算圆周率π的值
sickbaimu的博客
06-14 4714
简单的mfc中利用多线程逐步输出pi的值（800位），可以中途暂停和继续，顺便做了下界面和图标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极客范儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值