高精度（High Precision）

最新推荐文章于 2024-08-27 15:26:06 发布
最新推荐文章于 2024-08-27 15:26:06 发布
阅读量932 收藏
点赞数 1
分类专栏： algorithm 文章标签： java c/c++ 开发工具

   

       每每遇到“大明小明的A+B”，总有一股淡淡的忧伤．．．

 

加+

      在所有运算中，加法可以说是最简单的，但要实现得好，还是很考验功力的。

      我最原始的思维是，开两个字符数组分别保存两个加数，数组的每一个元素存储一个数字，（一开始为了节省空间，没有将字符数组转换为整型数组，发现操纵字符数组比操作整型数组更容易出错），为了计算方便，字符数组转换为整型数组，然后就是对应位的数字相加，逢十进一就可以了。

       核心部分代码如下：

    int i;
    for(i = 0; i < LEN; i++)
        sum[i] = a[i] + b[i];
    for(i = 0; i < LEN; i++)
        if(sum[i] >= 10)
        {
            sum[i] -= 10;
            sum[i+1] += 1;
        }
    return sum;

      这样的代码一写出来，虽然是正确的，但感觉就不是很好，空间的浪费在所难免，但是一位一位数字计算，速度会有点慢。

      改进：数组每个元素存储4位数字，上面代码只需把10改为10^4就行了（虽然只是轻描淡写般一改，却是很难想到的，当然可以取10^3，10^5，但只有10^4这个数字对乘法运算有很大的意义——10^4^2不至于超过int表示范围）

 

减-

      （这个和加法差不多，如果涉及到结果为负数，稍复杂，但就此略过）

 

乘*

      依然是模拟手算，乘数i位和被乘数j位相乘，放在结果的i+j位，然后处理进位就ok了。

    for(i=a.len-1; i>=0; i--)
        for(j = b.len-1 ; j >=0 ; j--)
        {
            m = a.v[i]*b.v[j];
            res.v[i+j] += m % base;
            res.v[i+j+1] += m / base;
            if(res.v[i+j] >= base)
            {
                res.v[i+j+1]+=res.v[i]/base;
                res.v[i+j]%=base;
            }
        }
    res.len = a.len+b.len+5;
    while(res.len > 0 && res.v[res.len-1] == 0)res.len--;
    return res;

 

除/

      除法相对来说是最难的。

      一开始我想：除法是一种匹配，是看被除数最多可以分成多少个除数，这样就又转到减法上去了，每减一次除数，商就加1，直到不能再减，商也就出来了。

      但是，很容易想像：当被除数极大而除数极小的时候那个速度啊，真让人心惊胆战。

      可以这样改进：不再一次一次减，而是从最高位开始，每次减去10^n倍除数，当被除数剩下的值不够减去10^n倍除数的时候，改为减去10^(n-1)倍除数……

      代码很繁琐：

#include<iostream>
#include<cstring>
#define M 200
using namespace std;
//单次减法操作
int Substract(int *p1, int *p2, int len1, int len2)
{
    int i;
    if(len1 <len2)
        return -1;
    if(len1==len2)
    {
        for(i=len1-1; i>=0; i--)
        {
            if(p1[i]>p2[i])break;
            else if(p1[i]<p2[i]) return -1;
        }
    }
    for(i=0; i<len1; i++)
    {
        p1[i]-=p2[i];
        if(p1[i]<0)
        {
            p1[i]+=10;
            p1[i+1]-=1;
        }
    }
    for(i=len1-1; i>=0; i--)
    {
        if(p1[i])return i+1;//找到最高位第一个不为0
    }
    return 0;
}

int main()
{
    char a1[M],a2[M];
    int b1[M],b2[M],result[M];
    while(cin >> a1 >> a2 )
    {
        memset(b1,0,sizeof(a1));
        memset(b2,0,sizeof(a2));
        memset(result,0,sizeof(result));
        int len1 = strlen(a1);
        int len2 = strlen(a2);
        int i,j;
        for(j=0,i=len1-1; i>=0; i--)
            b1[j++]=a1[i]-'0';
        for(j=0,i=len2-1; i>=0; i--)
            b2[j++]=a2[i]-'0';
        if(len1<len2)
        {
            cout << "0\n"<< endl;
            continue;
        }
        int nTimes = len1-len2;
        if(nTimes>0)
        {
            for(i=len1-1; i>=nTimes; i--)
                b2[i]=b2[i-nTimes];
            for(; i>=0; i--)
                b2[i]=0;
            len2=len1;
        }
        for(j=0; j<=nTimes; j++)
        {
            int nTemp;
            //一直减到不够减为止
            //先减去若干个 a2×(10 的 nTimes 次方)，
            //不够减了，再减去若干个 a2×(10 的 nTimes-1 次方)，......
            while((nTemp = Substract(b1, b2+j, len1, len2-j)) >= 0)
            {
                len1 = nTemp;
                result[nTimes-j]++; //每成功减一次，则将商的相应位加1
            }
        }
        //输出部分
     for(i=M-1; (i>=0)&&(result[i]==0); i--);
        if(i>=0)
        {
            for(; i>=0; i--)
            {
                cout << result[i];
            }
        }
        else
        {
            cout << "0";
        }
        cout << endl;
    }
    return 0;
}

 

      至此，+-*/都完成了！！！确实值得庆祝，仔细想想，又悲从中来...

 

      加减乘除彼此之间不是相互独立的，而自己却没有利用好已经已完成的功能去实现未完成的功能，导致代码臃肿不堪，难成模版。要实现除法其实可以借助已经实现的乘法和加法。

 

 

做成模版吧

   

       C++提供了重载运算符的契机，再自定义一个bint类型，那就完胜了。自己又重写了一遍高精度，虽然比起以前有所进步，但是，看到“神的代码”，又感伤了。（搬一笑话来自虐：一菜鸟和老牛去实现同一个功能。老牛很神气地说：你的代码运行比我的快吗？菜鸟不以为然地回答：你的代码有我的长吗？）

 

      （代码有点长，贴于博文最后）

 

 

高精度小数

 

      我的思路：把小数分成整数部分和小数部分分别处理，然后处理小数进位情况，再处理整数部分。

      想着挺简单的，但写过之后会发现，高精度小数是最令人神伤的。进位的处理，前导零、末尾零的处理都要比整数来得精确。以下是自己曾经遇到的bug：

      1.   1.1 + 0.9 = 2.     （小数点没判断好）

      2.   0.1 + 0.2 = .3     （自己任性地把所有前导0都消掉了）

      3.   0.5 + 0.6 = 0.1   （小数部分和整数部分没有衔接好）

      4.   0.01 + 0.09 = 0.10  （末尾0没处理）

      

 

总结：

 

      以前总依赖java提供的BigDecimal和BigInteger类，自己却从没有真正去思考去动手实现，后来这两个类用着用着，自己感到特不爽，不管哪个运算，都得用一个函数去完成，哪有运算符号来得直观。所以一怒之下，就敲开了。

      这是一门数字控制艺术，必须全神贯注，将一个个数打散再重新组合。差之毫厘，将谬以千里。

      还是非常兴奋能沉下心写几遍高精度代码并基本完成。虽然与神的代码差距颇大，不过有差距才有进步。但是，什么更能让自己兴奋呢？



                    上面一个是自己写的高精度小数，下面一个是用java的BigDecimal类

 

       虽然我代码比较长，但是我占用空间小，运行速度快！吼吼~~~

    

 

 

高精度小数：

 

#include<iostream>
#define M 500
using namespace std;
int main()
{
    string s1,s2;
    while(cin >> s1 >> s2)
    {
        int d1[M]= {0},g1[M]= {0},d2[M]= {0},g2[M]= {0},rd[M+10]= {0},rg[M+10]= {0};
        int i1=s1.find('.');
        int i2=s2.find('.');
        if(i1==-1)//要是输入的是整数，自己添加小数点吧
     {
            s1+=".0";
            i1=s1.find('.');
        }
        if(i2==-1)
        {
            s2+=".0";
            i2=s2.find('.');
        }
        int i,j,k1,k2;
        for(k1=0,i=i1+1; s1[i]!='\0'; i++,k1++)
            d1[k1] = s1[i]-'0';
        for(k2=0,i=i2+1; s2[i]!='\0'; i++,k2++)
            d2[k2] = s2[i]-'0';
        int len = max(k1,k2);
        for(i=0; i<len; i++)
            rd[i]=d1[i]+d2[i];
        for(j=i-1; j>=0; j--)
            if(rd[j]>=10)
            {
                rd[j]-=10;
                if(j!=0)
                    rd[j-1]++;
                else rg[0]++;
            }
        for(k1=0,i=i1-1; i>=0; i--,k1++)
            g1[k1]=s1[i]-'0';
        for(k2=0,i=i2-1; i>=0; i--,k2++)
            g2[k2]=s2[i]-'0';
        len = max(k1,k2);
        for(i=0; i<len; i++)
            rg[i]+=(g1[i]+g2[i]);
        for(i=0; rg[i]!=0; i++)
            if(rg[i]>=10)
            {
                rg[i]-=10;
                rg[i+1]++;
            }
        for(i=M+9; i>=0; i--)if(rg[i]!=0)break;
        for(j=i; j>0; j--)cout<<rg[j];
        cout<<rg[0];
        for(i=M+9; i>=0; i--)
            if(rd[i]!=0)
            {
                j=i;
                break;
            }
        if((i+1)==0)
        {
            cout<<endl;
            continue;
        }
        cout<<".";
        for(i=0; i<=j; i++)cout<<rd[i];
        cout << endl;
    }
    return 0;
}

 

大数模版：

#include<stdio.h>
#include<string.h>
const int base=10000; // base^2 fit into int
const int N=1000;//the length to offer
struct bint
{
    int len,v[N];
    bint(int r=int())//struct constructor. initialization necessary。
    {
        //with not initialze the v[0],I spend 3 more hours debugging this program
        //why it's so small but so important?
        //For it has effect on the case where cast int 0 to bint 0 ; or v[0] would be an uncertain result
        for(len=0,memset(v,0,N*sizeof(int)); r>0; r/=base)v[len++]=r%base;
    }
    bint& operator = (const bint& a)
    {
        memcpy(this,&a,(a.len+1)*sizeof(int));
        return *this;
    }
};

bool operator < (const bint& a,const bint& b)
{
    //神的代码
    int i;
    if (a.len != b.len) return a.len < b.len;
    for (i = a.len - 1; i >= 0 && a.v[i] == b.v[i]; i--);
    return i < 0 ? 0 : a.v[i] < b.v[i];
    /*我的代码 same idea, different code length 
    if(a.len<b.len)return 1;
    else if(a.len>b.len)return 0;
    else
    {
        int i;
        for(i=a.len-1; i>=0; i--) //！don't set i to a.len
        {
            if(a.v[i]<b.v[i])return 1;
            else if(a.v[i] > b.v[i])return 0;
            else continue;
        }
        if(i==-1)return 0;
    }
    return 0;*/
}
bool operator <= (const bint& a,const bint& b)
{
    return !(b<a);
}
bint operator - (const bint& a,const bint& b)
{
    //神的代码
    bint res;
    int i, cy = 0;
    for (res.len = a.len, i = 0; i < res.len; i++)
    {
        res.v[i] = a.v[i] - cy;
        if (i < b.len) res.v[i] -= b.v[i];
        if (res.v[i] < 0) cy = 1, res.v[i] += base;
        else cy = 0;
    }
    while (res.len > 0 && res.v[res.len - 1] == 0) res.len--;
    return res;
    /*我的代码 it works
    bint res;
    int i;
    for(i=0,res.len=a.len; i<res.len; i++)
        res.v[i]=a.v[i]-b.v[i];
    for(i=0; i<res.len; i++)
        if(res.v[i]<0)
        {
            res.v[i]+=base;
            res.v[i+1]--;
        }
    while (res.len > 0 && res.v[res.len - 1] == 0) res.len--;
    return res;*/
}
bint operator + (const bint& a,const bint& b)
{
    //神的代码
    bint res;
    int i, cy = 0;
    for (i = 0; i < a.len || i < b.len || cy > 0; i++)
    {
        if (i < a.len) cy += a.v[i];
        if (i < b.len) cy += b.v[i];
        res.v[i] = cy % base;
        cy /= base;
    }
    res.len = i;
    return res;
/*我的代码，lots of bugs
    bint sum;
    memset(&sum,0,sizeof(bint));
    int i;
    for(i=0; a.v[i]!=0||b.v[i]!=0; i++)//这里不应该用v[]是否等于0来判断，可以用N，但用len属性可以更快更准确
        sum.v[i]=a.v[i]+b.v[i];
    sum.len = i;
    for(i = 0 ; i<sum.len; i++)
        if(sum.v[i]>=base)
        {
            sum.v[i]-=base;
            sum.v[i+1]+=1;
        }
    return sum;
*/

}
bint operator *(const bint& a,const bint& b)
{
    //神的代码
    bint res;
    res.len=0;
     if (0 == b.len)
    {
        res.v[0] = 0;
        return res;
    }
    memset(&res,0,sizeof(bint));
    int i,j,t;
    for(i=0; i<a.len; i++)
    {
        for(j=t=0; j<b.len||t>0; j++,t/=base)
        {
            t+=a.v[i]*b.v[j];
            if(i+j<res.len)t+=res.v[i+j];
            if(i+j>=res.len)res.v[res.len++] = t % base;
            else res.v[i+j] = t % base;
        }
    }
    return res;
    /*我的代码
    for(i=a.len-1; i>=0; i--)
        for(j = b.len-1 ; j >=0 ; j--)
        {
            m = a.v[i]*b.v[j];
            res.v[i+j] += m % base;
            res.v[i+j+1] += m / base;
            if(res.v[i+j] >= base)
            {
                res.v[i+j+1]+=res.v[i]/base;
                res.v[i+j]%=base;
            }
        }
    res.len = a.len+b.len+5;
    while(res.len > 0 && res.v[res.len-1] == 0)res.len--;
    */
}

bint operator / (const bint& a,const bint& b)
{
    //神的代码，自己还写不出除法
    bint res,mod;
    memset(&res,0,sizeof(bint));
    if(a.len<b.len)
        return res;
    mod.v[0]=mod.len=0;
    int rt,lt,mid,i;
    for(i = a.len-1 ; i >= 0;i--) //！防越界
    {

        mod = mod * base + a.v[i];write(mod);
        for(lt = 0,rt = base - 1 ; lt < rt;)
        {
            mid = ( lt +rt+ 1) / 2; //二分加速
            if(b * mid <= mod) lt = mid;
            else rt = mid -1;
        }
        res.v[i] = lt;
        mod = mod - b * lt;
    }
    res.len = a.len;
    while(res.len > 0 && res.v[res.len - 1]==0)res.len--;
    return res;//return mod 就是取模运算
}

bint operator %(const bint& a,const bint& b) //almost the same code in operator /
{
    bint mod;
    mod.v[0]=mod.len=0;
    int rt,lt,mid;
    for(int i = a.len-1 ; i >= 0; i--) //！越界问题
    {
        mod = mod * base + a.v[i];
        for(rt = base - 1, lt = 0; lt < rt;)
        {
            mid = (rt + lt + 1) / 2; //二分加速
            if(b * mid <= mod) lt = mid;
            else rt = mid -1;
        }
        mod = mod - b * lt;
    }
    return mod;
}
bool read(bint& a,char buf[])
{
    if(scanf("%s",buf)!=1)return 0;
    memset(&a,0,sizeof(bint));//先初始化为0，不然当输入0的时候，a的值不被覆盖
    if(buf[0] == '0' &&  buf[1]=='\0')return 1;
    int w,u,len=strlen(buf);
    for(w=1,u=0; len;)
    {
        u += (buf[--len]-'0') * w;
        if(w*10 == base)
        {
            a.v[a.len++] = u;
            u = 0;
            w = 1;
        }
        else w*=10;
    }
    if(w!=1)a.v[a.len++]=u;
    return 1;
}

void write(const bint& a)
{
    printf("%d",a.len==0?0:a.v[a.len-1]);
    for(int i=a.len-2; i>=0; i--)
        printf("%04d",a.v[i]);
    printf("\n");
}

      

    神的代码总能令人赏心悦目，isn't it ?

 

iteye_4145
关注
专栏目录
c++高精度计算20除法High-precision20calculate240101
aw344的专栏
04-06 216
比如要计算 sin⁡(π6)sin(6π​) 至少100位的精度，你可以考虑使用如GNU Multiple Precision Arithmetic Library (GMP) 或者MPFR库来处理高精度数学运算。MPFR库是专门为了提供一个可靠的多精度浮点数计算平台，能够保证结果的准确性，包括四舍五入的控制。为实现一个基本的 高精度计算 c++库,应该从最基本的。要在C++中实现高精度和高性能的计算，大数的 加减乘除 撸起……
高精度（简略版）
zl9355的博客
12-31 401
在我们进行计算的过程中，经常会遇到几十位，甚至几百位的数字的计算问题，也有可能会遇到小数点后几十位，几百位的情况，而我们面对这样的情况下， 和 的数据范围显然是不够使用的了。//-------------------------初始化------------------------------//乘法进位: c[i + j - 1] = a[i] * b[j] + x + c[i + j - 1];
高精度
再看_的博客
02-12 1984
加法 #include<bits/stdc++.h> using namespace std; vector<int> add(vector<int> &a,vector<int> &b) { vector<int > c; int t=0; for(int i=0;i<a.size() ||i<b.size();i++) { if(i<a.size()) t+=a[i]; if(i<b.
什么是高精度？
jjmhx的专栏
08-27 619
高精度计算其实也没那么神秘，无非就是单独存储各个位上的数字（通常使用数组），然后就像我们人工计算那样逐位计算，只不过这个过程中可能会用到某些高级算法来提高运算效率。高精度（High Precision）计算是指处理那些超出了标准数据类型（如整数、浮点数等）表示范围或精度限制的数值运算。对于浮点数来说，本身就存在精度不高的问题。当有更高的精度要求时（典型的就是金融领域），就得用到高精度计算。我们常用的数据类型（如int型）都是有能表示的数据范围的，超出了范围自然计算结果就会存在偏差。
高精度算法(high precision algorithm)
07-14
自己编的高精度，有点小问题，大佬可以帮忙看一看，蒟蒻可以直接拿走（除了div和mod以外），喜欢的记得三联哦（你的收藏是我最大的动力）
ACM高精度运算ACM（ACM high precision operation ACM）.pdf
最新发布
11-08
ACM高精度运算ACM（ACM high precision operation ACM）
high Precision Multiplication(高精度乘法)
weixin_46696889的博客
09-28 166
high Precision Multiplication 高精度乘法之竖式乘法的实现! Part 1. Source Code #include <iostream> using namespace std; #include <string> #include <vector> int main() { string a, b; cout << "Please input two integers: " << endl; cin &gt
gaojingdu.zip_高精度_高精度算法 c_高精度计算
09-21
在计算机科学中，高精度计算（High-Precision Computing）是指使用大整数或者浮点数进行精确计算的方法，通常涉及到的领域包括数学、物理、工程、金融等需要精确计算的场景。在C语言中实现高精度算法，需要设计一套...
High precision Configuration
一天不进步，就是退步.
11-13 415
ETL开发项目中遇到过一个很奇特的问题，源表的主键是number类型，精度大于15，抽取到目标表的过程中，通过debugger调试器查看会生成科学计数法的格式，workflow运行完成后，主键相差很小的数字结果却变成了很多相同的数字，然后程序报主键重复错误，当时也走了很多弯路，花了好长时间去解决这个问题。 原因：没有启用高精度 解决办法：可以在Task的Properties页签中勾选“
高精度（C++）
Annabel_CM的博客
07-08 763
高精度加法 基本思路 高精度减法 基本思路 将数据的每位数从个位开始依次存入数组中，例如A[i] B[i]，假定 A >= B : 先比较A[i] 和B[i] 的大小，若A[i] - B[i] - t(借位） >= 0: A[i] - B[i] - t; 若A[i] - B[i] - t < 0: A[i] - B[i] + 10 - t; 高精度乘法 基本思路 将A的每位数从个位开始依次存入数组中，例如A[i]， 将B看成一个整体，从个位数开始A[i] 乘以B，得出的结果从个
高精度加、减、乘、除算法实现详解
热门推荐
程序猿老樊的博客
04-16 4万+
       在说高精度加减乘除运算之前，我们先搞明白什么是高精度运算？       实际上高精度就是说参与运算的数据和运算结果的范围，超出标准数据类型能表示的数据大小范围的运算。这个时候，如果要得到正确的计算结果，显然不能依靠普通方法实现了。而要在普通运算原理的基础上，加以辅助算法来实现超大数据的计算。例如：求两个100位的数据的和，或者计算两个100位的数字乘积。这时就要用到高精度算法了。  ...
高精度算法
KING_阿飞的博客
10-26 4705
高精度 1.什么是高精度 高精度算法，属于处理大数字的数学计算方法。在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除，乘方，阶乘，开方等运算。对于非常庞大的数字无法在计算机中正常存储，于是，我们可以将这个数字拆开，拆成一位一位的，或者是几位几位的存储到一个数组中， 用一个...
算法之高精度（一）
weixin_43204180的博客
04-23 1241
这是关于高精度的介绍。 什么是高精度？在现实生活中，我们也会见到很多比较大的数字。比如说3141592662623。我们在表示这些数字的时候常常会使用一些单位（万，亿，十亿等等），比如说，三万一千四百一十五亿九千二百六十六万二千六百二十三。但计算机中并不是这样表示的，计算机中使用的是二进制表示，而不是十进制。 电脑中表示一个数字所使用的二进制数量是有限的，通常是32位或64位。32位所能表示的最大数是231，使用估算的话，大概是21亿左右。这是int类型的极限了。64位所能表示的最大数是263，估算得到的数
matlab high precision floating 工具包
12-31
MATLAB高精度浮点数工具包可以用于处理需要更高精度计算的数值计算问题。在传统的计算机表示方法中，浮点数通常以有限的位数进行存储和计算，导致精度的损失。但是在某些科学、工程和金融领域，对计算结果的精确度有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值