精华内容
下载资源
问答
  • C++实现高精度计算类库,包含了FFT的乘法除法,开平方,用法类似java的bigint,实测速度比java的快很多
  • #1 对数值进行取整: # 1.1 问题: 对浮点型数据取固定小数位的小数 # 1.2 解决方案: 简单的取整操作,使用内建的round(value,ndigits)即可 #round的ndigits省略时,会取得整型;当ndigits == 0时,取得小数;...
  • 美国国家半导体公司(National Semiconductor Corporation)宣布推出5款高精度运算放大器,即使增益操作超过6V/V,也可领信号调节和传感器接口保持极高的准确度,非常适合对高精度和高增益要求较高的应用,如便携式...
  • 用于Visual studio 高精度计算库项目文件; 包括了gmp, mpir, mpfr, gmp, 等,可以直接在visual studio中编译成为静态或动态链接库,用于作超高精度数值计算时调用; 跟Eigen C++ tempalte library库和Pavel写的mpfr C++...
  • 完整版高精度运算模块2.1版.rar
  • 高精度运算

    2012-05-22 15:24:35
    高精度运算
  • 大浮点数数加减乘除,进制转换,求表达式的值
  • 对于超大数字的运算,用long long int仍然不能解决,这时候就需要考虑通过模拟运算和数组存储来实现高精度运算。 本文讨论借助C++的string来实现高精度的运算。 首先输入的量直接存储为string,设为s1和s2。 接下来...
  • 最详细全面的黄金分割高精度计算算法资料,值得一看!(C/C++)
  • 高精度计算1

    2018-10-24 12:27:06
    高精度计算,包括高精度加减乘(如何存储大整数?如何实现?如何进位?)
  • 关于高精度的基本运算,包括加减乘除和阶乘,是用c语言实现的,绝对的好东西
  • JAVA 高精度计算

    千次阅读 2019-05-08 20:25:39
    高精度计算 用cpp实现较为复杂 但对于java 的Biginteger 和 Big Decimal来说就容易许多了。 先来一道题: http://codeforces.com/gym/101848/problem/A 总结一下各种类型的精度: 对于超过18位的运算,及时long ...

    高精度计算 用cpp实现较为复杂 但对于java 的Biginteger 和 Big Decimal来说就容易许多了。

    先来一道题:
    http://codeforces.com/gym/101848/problem/A

    总结一下各种类型的精度:
    在这里插入图片描述
    在这里插入图片描述

    对于超过18位的运算,及时long 也不能精确表达式。(在cpp中 unsign long 是long 的两倍)

    好在java中有两个 Big Numbers

    • 理论上来说,内存有多大,这个数就能有多大。

    BigInteger 和 BigInteger 的相关方法:
    在这里插入图片描述
    在这里插入图片描述

    两者的相互转化:

    //BigDecimal to BigInteger
           BigDecimal x1 = in.nextBigDecimal();
           BigInteger xx1 = x1.toBigInteger();
    
    //BigInteger to BigDecimal
           BigDecimal result1 = new BigDecimal(xx1.toString());
    

    题目的代码

    
    
    import java.math.*;
    import java.util.Scanner;
    
    public class Test1{
        public static void main(String arg[]){
    
     
            Scanner in = new Scanner(System.in);
            BigDecimal x1 = in.nextBigDecimal();
            BigDecimal x2 = in.nextBigDecimal();
            in.close();
    
            BigDecimal xx = BigDecimal.valueOf(1e9);
            x1=x1.multiply(xx);
            x2=x2.multiply(xx);
         
            BigInteger xx1 = x1.toBigInteger();
            BigInteger xx2 = x2.toBigInteger();
     
            BigInteger result = xx1.mod(xx2);
    
            BigDecimal result1 = new BigDecimal(result.toString());
            result1 = result1.divide(new BigDecimal(1e9));
            
            System.out.printf("%.9f\n",result1);
        }
    }
    
    展开全文
  • 高精度计算

    2017-08-08 19:30:37
    高精度计算PPT
  • 用C/C++实现基本高精度计算

    千次阅读 2020-11-23 14:57:09
    常规的整数运算中,运算范围都不能超过64bit……如何突破这一限制?

    (前置技能:小学数学知识,C语言基础)

    什么是高精度

    我们知道,C/C++在64位编译器中支持的环境下,其各种整型数据类型表示是有范围的。

    类型名             			 		  	  取值范围
    signed char        			   		     -128~127
    unsiged char					  	  	    0~255
    short int        			  	       -32768~32767
    int            		 			  -2147483648~2147483647
    unsigned int								0~4294967295
    long         	          		  -2147483648~2141483647
    unsigned long 								0~4294967295
    long long 	 		     -9223372036854775808~9223372036854775807
    unsigned long long 						    0~18446744073709551615
    

    尽管long long类型(或者在有些编译器中表示为__int64.注意int64前面有2个下划线)能表示的数已经相当大了,但和一些天文数字比起来,它连屏幕的一行都占不到。很多实际数学问题其实是long long也无法解决的。
    例如,围棋的走法有3的361次方,这个数字怎么显示出来?宇宙中原子的总和是10的80次方,怎么显示出来?这些都是语言本身的数据类型无法表示的。实际上,这些数字如果用二进制去储存的话,需要的空间也是特别大的。为了节约空间,同时让我们能够算出这些大数据,我们需要一种应用数组进行模拟计算的方法——高精度计算。

    高精度算法

    提醒:本博文该部分的所有代码均只用于展示计算原理,如果要整合在一起并进行更加复杂的符合操作,会产生诸多bug(其实直接复制粘贴任何一段都可能会有问题)总之就是,在这里找不到板子啦

    高精度数的读写

    1. 读入高精度数
      直观地输入一个高精度数时,我们需要存储一个有很多很多位的数字.
      如何存储?最直接的方法就是将它存入一个字符串.
      例如,我们可以这样:
    char str[100] = {""};//100表示数据可能的最大位数.
    scanf("%s, &str);
    

    这种输入方式再简单不过了,我们输入“43983926969436339448266492\n”
    则数据“43983926969436339448266492”就被存入其中了
    (提示:彩蛋数据)
    2. 存储高精度数
    现在,数据的读取完成了,我们应该如何处理这个数,让他变得方便于计算呢?
    我们不妨再设置一个数组,然后将输入的数逆序存入,也就是将str的最后一位存入数组a的第0位、将str的倒数第二位存入数组a的第1位……

    #include <string.h>
    
    int a[100] = {0};//100应该为这个数据可能的最大位数.
    for(int i = 0; i < strlen(str); ++i)
    	a[i] = str[strlen(str) - i - 1] - '0';
    

    这个时候就有人会问了:为什么要逆序存储?
    这是因为,数据的长度毕竟不确定,高精度计算既然是利用数组计算,应当是需要每一位每一位对齐再处理运算. 如果顺序存储,两个数长度不一样,最后一位的下标也不同,最后处理运算时最后一位不能直接对齐,还要经过一个移位的操作,显然加大了计算机的操作量. 反之,如果我们采取逆序存储的方式,存入的数组从第0位开始依次是个位、十位、百位……这些对应关系不会随着数据的长度改变而改变,有利于后面对两个高精度数进行运算.
    ——————————————————————————

    高精度加法

    了解了高精度的输入与存储后,我们可以定义一个表示高精度数据的结构体:

    #define LEN 1001//假定1001是我们处理的所有数据的最大位数
    
    struct hp{
        char str[LEN];
        int a[LEN];
    };
    

    为了进行加法,我们可以先准备3个结构体,分别作为两个加数和和. 注意定义后,为了正确输入并在后续输出时检查前导0, 应该将结构体的字符数组初始化为空串,将a数组全部初始化为0.

    void init(struct hp *x)//初始化函数
    {
    	for(int i = 0; i < LEN; ++i)
    	{
    		x->a[i] = 0;
    		x->str[i] = '\0';
    	}
    }
    

    如何进行高精度的加法?
    回想小学数学,那一个个竖式,逢十进一,简便美观的十进制表达……哦,我的上帝,多么纯粹简朴的方法啊!
    于是,高精度加法,其实就是基于竖式运算原理的啦~正因如此,我们才需要对齐两个加数.
    加法:
    先获取两个加数中最大的位数len,则本次加法计算需要进行len次操作. 从第0位开始,每次将对应位相加,得到和在该位的数值. 如果和在该位的数值大于等于10,那么将其减掉10,并让高一位加1.

    void add(struct hp x, struct hp y, struct hp *ans)
    {
        int len = 0;
        if(strlen(x.str) > strlen(y.str))
            len = strlen(x.str);
        else len = strlen(y.str);
        for(int i = 0; i < len; ++i)
        {
            ans->a[i] += x.a[i] + y.a[i];
            while(ans->a[i] >= 10)
            {
                ans->a[i] -= 10;
                ans->a[i + 1]++;
            }
        }
    }
    

    加法计算器完整代码:

    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    #define LEN 1001//假定该程序处理的数据都是小于1000位的.
    /*最长位数1001是为了安全.*/
    
    struct hp{
        char str[LEN];
        int a[LEN];
    };//创建结构体hp(high-precision)
    //注意使用指针,这样来通过指针形参修改传入的实参.
    void init(struct hp *x)//hp初始化函数
    {
    	for(int i = 0; i < LEN; ++i)
    	{
    		x->a[i] = 0;
    		x->str[i] = '\0';
    	}
    }
    void in(struct hp *x)//输入函数.
    {
        scanf("%s", &x->str);
        int len = strlen(x->str);
        for(int i = 0; i < len; ++i)
            x->a[i] = x->str[len - i - 1] - '0';
    }
    void add(struct hp x, struct hp y, struct hp* ans)//加法函数
    {
        int len = 0;
        if(strlen(x.str) > strlen(y.str))
            len = strlen(x.str);
        else len = strlen(y.str);
        for(int i = 0; i < len; ++i)
        {
            ans->a[i] += x.a[i] + y.a[i];
            while(ans->a[i] >= 10)
            {
                ans->a[i] -= 10;
                ans->a[i + 1]++;
            }
        }
    }
    void show(struct hp ans)//输出函数
    {
        int j = LEN - 1;//数组有LEN位,其最后一个下标是LEN-1.
        while(ans.a[j] == 0 && j >= 1)
            --j;//跳过所有前导0.
            /*注:为了确保能输出结果0,前导0最多跳到第一位,
            不检查第0位是否为0,因此加了条件j >= 1.*/
           //现在,j的值是我们要输出的这个结果的最大位的下标.
        while(j >= 0)
        {
            printf("%d", ans.a[j]);
            --j;
        }
        printf("\n");
    }
    int main()
    {
        struct hp x, y, ans;
        init(&x);
        init(&y);
        init(&ans);
        in(&x);
        in(&y);
        add(x, y, &ans);
        show(ans);
        return 0;
    }
    
    

    以上就是进行高精度加法的过程了.


    高精度减法

    实现高精度减法,我们同样可以用三个结构体. 原理与加法相似,仍然是竖式原理:
    先获取被减数的位数len,则本次减法计算需要进行len次操作. 从第0位开始,每次将对应位相减,得到和在该位的数值. 如果和在该位的数值小于0,那么将其加上10,并让高一位减1.

     void minus(struct hp x, struct hp y, struct hp* ans)
    {
        int len = strlen(x.str);
        for(int i = 0; i < len; ++i)
        {
            ans->a[i] += x.a[i] - y.a[i];
            while(ans->a[i] < 0)
            {
                ans->a[i] += 10;
                ans->a[i + 1]--;
            }
        }
    }
    

    但是这样的减法是无法计算结果为负数的情况. 例如1 - 10.为了解决减法出现负数的问题,我们需要往结构体中添加一个表示正负的符号. 例如,添加一个bool值,并定义一个比较函数,利用其比较被减数和减数的大小(此处比较函数就交给你们啦). 当减数大于被减数,让设置的bool值为0,反之为1. 当bool值为1时直接进行减法运算. 如果bool值为0,就返回用减数减去被减数的结果.
    同样地,利用这个表示符号位的布尔值,我们还可以定义含有负数的加法,等等……


    高精度乘法

    要进行高精度乘法,我们会如何去操作?
    竖式乘法?我们很容易想到这样的方式:
    计算123 * 52,
    首先列竖式,让123乘以2,也就是让每一位乘以2,得到246.
    然后让123每一位乘以5,得到615(这里隐含了进位操作).
    最后,因为5是十位,它的位权是10,所以615修正为6150.
    让6150+246,得到结果6396.
    这个算法是可行的,让我们来看它的步骤应该如何设计:

    1. 首先获取被乘数和乘数的长度len1,len2;
    2. 定义len2个高精度数 a[len2],它们作为被乘数与乘数每一位分别相乘的结果;
    3. 每个 a[i] 拥有一个位权 j ,j 决定在后续处理中将所有 a[i] 相加时每个a[i] 要乘以10的幂数;
      (说白了就是为了模拟竖式乘法最后相加的过程)
    4. 取出乘数的第 i 位,让被乘数的每一位乘以这个数 ,并把乘得的结果存入a[i] 对应的位.
      (例如上方例子,123乘以5的时候,位权j为1,我们应当将结果15、 10、 5分别存入 a[1] 的第1(j + 0)位,第2(j + 1)位,第3(j + 2)位. 这里的a[1] 就是 {0,5,10,15} 了. 同理,我们知道 a[0] 为 {2,4,6}.)
    5. 最后一步和自然的竖式乘法的最后一步一致,让所有的 a[i] 相加. 因为我们在之前的讨论中已经封装了高精度的加法,并且进位判定都是用的while语句,因此无论 a[i] 的第几位有多大,最后相加的过程中也能利用进位得到正确结果了.

    代码实现:

    void multi(struct hp x, struct hp y, struct hp* ans)
    {
    	int len1 = strlen(x.str);
    	int len2 = strlen(y.str);
    	struct hp A[len2];//乘数有len2位.
    	/*这里应该还有一个使所有A.a[i]初始化为0的操作.
    	这里只展示乘法原理,略去.*/
    	for(int i = 0; i < len2; ++i)
            {
                //每个因子进i位.
                int n = y.a[i];//注意取n为被乘数的第i位.
                //让A[i]的每一位都乘上这个数.
                int u = i;
                for(int j = u; j < u + len1; ++j)
                    A[i].a[j] = x.a[j - u] * n;
            }
            //让所有因子相加.
            for(int i = 0; i < len2; ++i)
            {
            	struct hp tmp;
              	ans = add(ans, A[i], tmp);
            }
            return ans;
    }
    

    高精度除法及求余

    高精度除法的原理仍然是基于竖式除法……只不过,为了方便代码更加容易理解,我们不妨换一种方式解释.
    譬如,我们现在要计算1234除以9.

    1. 首先,获取最大位是4.将其减1得到3.
    2. 9乘以10的3次幂,得到9000.
    3. 用1234减去9000,结果小于0,有效的减法为0次. 在结果的千位放置0.
    4. 将9000降幂变为900,用1234减去900,得到334. 再减一个900,小于0. 有效的减法为1次,在结果的百位放置1.
    5. 将900降幂得到90,用334减去90,可以减3次,得到64. 有效的减法为3次,在结果的十位放置3.
    6. 将90降幂得到9,用64减去9,可以减7次,得到1.在结果的个位放置7.
    7. 9已经是9乘以10的零次幂了,最后这个1小于除数,那么我们除法得到的余数是1.
    8. 故:1234除以9等于137,余1.

    那么,我们将其转化为可以被机器执行的描述:

    1. 如果被除数的位数(len1)小于除数的位数(len2),直接返回0. (余数为被除数.)
    2. 否则的话,获取除数位数,让其乘以10的(被除数位数-除数位数)次方,得到一个数b.
    3. 定义一个长度最长为被除数位数数组cnt[len1].
    4. 将被除数减去b. 每减去一次b,cnt[位数]++.
    5. 当被除数即将在减去后小于0时,不执行该步减法,让b缩小为原来的十分之一.
    6. 继续减,直到b和原来的除数相等.

    该算法的实现依赖于高精度乘法和高精度减法,只有这两种计算方法已经封装了才可以实现除法. 另外,同样需要一个比较函数.
    利用这个算法,我们就可以求出两个数的商和余数了.

    感受:ACM的日子,每周还是要学点东西的~

    展开全文
  • 德州仪器 (TI) 宣布推出两款针对高电压工业市场的全新的高精度运算放大器——OPA211 与 OPA827。 与业界同类 36V 放大器相比,两款放大器均实现了超低噪声、低功耗、小封装尺寸以及高带宽等多种特性的完美结合,为...
  • JS的高精度计算(BigDecimal)

    热门讨论 2011-01-18 19:41:00
    你是否因为JS端的小数计算精度不足而发愁过呢 其实有个不错的资源可以利用。 引用附件的JS,就可以轻松搞定JS的计算问题了。 使用例 <!-- function //+ alert(new BigDecimal("10").add(new BigDecimal("3E+...
  • 高精度运算——加减乘除(超详细模板)

    千次阅读 多人点赞 2020-03-25 08:27:33
    文章目录奇淫巧计——高精度运算(基础版)高精度介绍什么是高精度总的思路输入&输出代码加法运算思路代码N进制计算减法运算思路代码乘法运算高精度数组×\times×单精度数字思路代码高精度数组×\times×高精度...

    奇淫巧计——高精度运算(基础版)

    高精度介绍

    什么是高精度

    高精度运算也称之为大数运算。即:在变量运算对象的数值范围为任何数据类型所无法容纳的情况下,采用整数数组存储(用字符串表示数字)。

    总的思路

    对于一位高精度数字,用整数数组存储,数组每一个元素对应一位十进制数,由其下标顺序指明位序号。
    1、采用数串形式输入,并将其转化为整数数组。
    2、用一个整数变量记录数据的实际长度(即数组的元素个数)
    3、该数组的运算规则如同算术运算。

    输入&输出

    代码

    void init(int a[]) //输入
    {
      string s; 
      cin>>s;//读入字符串s 
      a[0]=s.length();  //用a[0]计算字符串s的位数
      for(i=1;i<=a[0];i++)
    	 a[i]=s[a[0]-i]-'0'; //将数串s转换为数组a,并倒序存储. 	  
    }
    
    
    void print(int a[ ])  //输出
    {
      int i;
      if (a[0]==0)
      {
        cout<<0<<endl;
        return ;
       }
      for(i=a[0];i>0;i--)//倒序输出 
        cout<<a[i];
      cout<<endl;
      return ;
    }
    
    

    加法运算

    思路

    1.两数之和的位数最大为较大数的位数加1。例如:999+999=1998
    2.观察人工计算的方法:竖式加法在这里插入图片描述
    观察可知,两元素相加需要加上低位来的进位,如果结果>=10则向高位发生进位,否则不产生进位。

    代码

    void  add(int a[],int b[]) //计算a=a+b 
    {
        int i,k; 
        if(a[0]<b[0]) a[0]=b[0]; //确定加法最大位数 
        
        for(i=1;i<=a[0];i++) a[i]+=b[i]; //逐位相加,得到的结果暂时不进位
    	 
        for(i=1;i<=a[0];i++)  //处理进位
         {  
    	    a[i+1]+=a[i]/10;
            a[i]%=10;
        } 
        if(a[a[0]+1]>0) a[0]++;//修正新的a的位数(a+b最多只能的一个进位) 
    }
    

    N进制计算

    1、当前位规范由%10改为% n
    2、进位处理由/10改为/n
    3、其他运算规则不变

    减法运算

    思路

    1.观察人工计算的方法:竖式减法
    在这里插入图片描述
    可知:两元素相减,需要考虑来自低位借位、向高位借位
    注意:这里是 被 减 数 a > 减 数 b 被减数a>减数b a>b,如果相反,则改成 b − a b-a ba加个负号

    代码

    int compare (int a[],int b[]) //比较大小
    { 
        int i; 
        if (a[0]>b[0]) return 1;//a的位数大于b则a比b大 
        if (a[0]<b[0]) return -1;//a的位数小于b则a比b小 
        for(i=a[0];i>0;i--)  //从高位到低位比较 
         { 
    	    if (a[i]>b[i]) return 1; 
            if (a[i]<b[i]) return -1;
        } 
        return 0;//各位都相等则两数相等。 
    } 
    
    void sub(int a[],int b[])//计算a=a-b
    {  
        int flag,i; 
        flag=compare(a,b); //调用比较函数判断大小
    	 
        if (!flag) {a[0]=0;return;} //相等
    	 
        if(flag==1) //大于   
         { 
    	    for(i=1;i<=a[0];i++) 
            {
    		    if(a[i]<b[i])//若不够减则向上借一位 
    			{    
    			    a[i+1]--;//记得高位减一 
    				a[i]+=10;
    		    } 
                a[i]=a[i]-b[i];
           } 
           while(a[a[0]]==0) a[0]--; //修正a的位数 
           return;
        } 
       if (flag==-1)//小于  则用a=b-a,然后前面加个负号 
       { 
            cout<<"-"; //先输出负号 
            for(i=1;i<=b[0];i++)
            {
    		    if(b[i]<a[i]){b[i+1]--;b[i]+=10;} //若不够减则向上借一位 
                a[i]=b[i]-a[i];//记住要把结果储存在数组a中 
    	   } 
            a[0]=b[0]; 
            while(a[a[0]]==0) a[0]--; //修正a的位数 
            return;
       } 
    }
    

    乘法运算

    这里分为两种情况:
    1、高精度数组a乘整数x
    2、两个高精度数组相乘(也可以解决第一个情况)

    高精度数组 × \times ×单精度数字

    思路

    参考加法,考虑进位即可

    代码

    int mult(int a[],int k)   //a=a*k,k是单精度数   
    { 
        int i; 
        if(k==0)  //处理k=0 
    	{      
    	    for(i=0;i<=MAXN;i++)  a[i]=0;
    		a[0]=0;
    		return 0;
       } 
        for(i=1;i<=a[0];i++)//先每位乘起来
    	    a[i]=a[i]*k;   
        for(i=1;i<=a[0];i++)  //处理进位
        { 
    	    a[i+1]+=a[i]/10;
            a[i]%=10;
       }
        while(a[a[0]+1]>0)//处理最高位相乘的进位
        { 
            a[0]++; 
            a[a[0]+1]=a[a[0]]/10;
            a[a[0]]=a[a[0]]%10;
       }
      return 0; 
    }
    

    高精度数组 × \times ×高精度数组

    思路

    观察人工计算方法
    在这里插入图片描述
    可以得到:
    1.积的位数为 a [ 0 ] + b [ 0 ] − 1 a[0]+b[0]-1 a[0]+b[0]1(暂时不考虑进位)
    2. a i ∗ b j a_i*b_j aibj应该累加在积的第 i + j − 1 i+j-1 i+j1 位上:
    for(i=1;i<=a[0];i++) for(j=1;j<=b[0];j++) c[i+j-1]+=a[i]*b[j];
    3.可以先乘、后处理进位
    注:不是很理解的话可以手写一下竖式乘法

    代码

    void mult(int a[],int b[],int c[])//c=a*b
    {     
        int i,j,len;
        for(i=1;i<=a[0];i++)
            for (j=1;j<=b[0];j++)
                c[i+j-1]+=a[i]*b[j];
        c[0]=a[0]+b[0]-1; 
        for(i=1;i<=c[0];i++)
        {
            c[i+1]+=c[i]/10;
            c[i]%=10;
       }
       while(c[0]>0&&c[c[0]]==0) c[0]--;
       return ;
    }
    

    除法运算

    这里分为两种情况:
    1、整数数组除以整数(a=a/b,a为整数数组,b为整数)
    2、高精度除法x=x/y(被除数x和除数y为整数,解决计算精度和循环节的问题)
    (也可以解决第一个情况)

    高精度除以单精度

    思路

    我们按照由高位到低位的顺序,逐位相除。在除到第i位时,该位在接受了来自i+1位的余数( a [ i ] = a [ i ] + 余 数 ∗ 10 a[i]=a[i]+余数*10 a[i]=a[i]+10)后与b相除。如果商最高位为0,则长度减1。

    代码

    void div(int a[],int b,int c[],int d)//c=a/b,d=a%b
    {  
        int i; d=0;  //余数初始化
        for(i=a[0];i>=1;i--)//按照由高位到底位的顺序,逐位相除
        {
    	    d=d*10+a[i];   //接受了来自第i+1位的余数
            c[i]=d/b;     //计算商的第i位
            d=d%b;       //计算第i位的余数
    	}
    	
    	/*计算商的有效位数*/
       c[0]=a[0];
       while(c[0]>0&&c[c[0]]==0) c[0]--;
       return ;
    }
    
    

    高精度除以高精度

    思路

    观察竖式除法(和自己手写的由些许差异,可以自己手写对比一下)
    在这里插入图片描述
    观察计算过程:
    1.除数移动对齐
    2.相除得商、余
    3.循环1、2
    代码实现:
    1.用numcpy()实现右移对齐(除数和被除数位数一致,由原始除数末尾补0得到)
    2.用减法模拟除法(循环相减直到被减数小于减数)
    3.循环1、2

    代码

    void numcpy(int a[],int b[],int dest) //右移对齐 
    {
    	for(int i=1;i<=a[0];i++)//注意我们是倒序储存得高精度数字
    	{
    		b[i+dest-1]=a[i];
    	}
    	b[0]=a[0]+dest-1;
     } 
    void div(int a[],int b[],int c[])//c=a/b 
    {
        int i,j,tmp[MAXN]; 
        c[0]=a[0]-b[0]+1;//可由a=c*b推出 
        for (i=c[0];i>0;i--)
        {
            memset(tmp,0,sizeof(tmp));       //清零 
            numcpy(b,tmp,i);                //将b拷贝到tmp的第i位,其余位是0
            while(compare(a,tmp)>=0)       //试商 
    		{
    		    c[i]++;
    			subtraction(a,tmp);      //用减法来模拟
    		}                                                          
        }
       while(c[0]>0&&c[c[0]]==0) c[0]--;
       return ;
    }
    
    
    展开全文
  • 面向单纯形的高精度计算算法设计.pdf
  • LMP2012WGLQMLV是美国国家半导体公司最近推出的全新高精度运算放大器系列中的首款双组装放大器。这款放大器已取得QMLV方面的认证,是太空通信系统的理想放大器。该双组装运算放大器最适用于卫星通信设备,例如高度及...
  • ST推出一个新的高精度运算放大器芯片,新产品在共模宽压下,保证超低的输入偏置电压。这个特性再加上极具竞争力的价格,使新产品TS507成为车用和工业应用的理想解决方案。  TS507采用ST的一项微调专利技术,输入...
  • 其实在写Java代码的时候,其实很少人会去考虑高精度运算,即使遇到无法避免高精度的计算问题也不会太烦恼,因为有大整数类BigInteger以及BigDecimal工具使用。但是抛开Java不说,举例:为一家银行计算员工工资,使用...

    其实在写Java代码的时候,其实很少人会去考虑高精度运算,即使遇到无法避免高精度的计算问题也不会太烦恼,因为有大整数类BigInteger以及BigDecimal工具使用。

    但是抛开Java不说,举例:为一家银行计算员工工资,使用JS去处理计算然后做页面展示的,但是因为银行系统 引入包是比较费劲的,所以第一次将高精度运算运用到工作中,之后由于使用Java越来越多,对于手撸高精度计算代码也就越来越少了。

    直到使用C++刷PAT算法的时候,又不可避免的使用到高精度算法(因为long int和long long也无法解决整数长度受限的问题), 所以用Java来实现高精度的运算,除法就先放一放,因为高精度除高精度有点难,今天小编就给大家分享下高精度的加减乘。先看一下效果图(上方结果使用BigInteger的方法,下方结果自定义实现)

    java高精度运算

    高精度的加法是比较容易理解的和实现,我们只需要注意进位就好, 将输入整数的字符串,进行遍历,将char类型转为int进行相加,保存进位在下一轮循环中使用即可。

    private static void add(String a, String b) {

    System.out.println("加===");

    BigInteger ba = new BigInteger(a);

    BigInteger bb = new BigInteger(b);

    System.out.println("结果=" + ba.add(bb));

    String res = "";

    int temp;

    int adv = 0;

    for (int i = a.length() - 1, j = b.length() - 1; i > -1 || j > -1; ) {

    if (i > -1 && j > -1)

    temp = (a.charAt(i--) - '0') + (b.charAt(j--) - '0');

    else if (i > -1)

    temp = (a.charAt(i--) - '0');

    else

    temp = (b.charAt(j--) - '0');

    temp += adv;

    adv = temp / 10;

    res = temp % 10 + res;

    if (adv != 0) {

    res = adv + res;

    System.out.println("结果=" + res);

    高精度减法和加法比较,稍微复杂一些,因为在减法中,需要根据输入数字的相对大小来判断是否输出负号,还需要注意是否要"借位",以及对于结果进行高位去0

    private static void sub(String a, String b) {

    System.out.println("减===");

    BigInteger ba = new BigInteger(a);

    BigInteger bb = new BigInteger(b);

    System.out.println("结果=" + ba.subtract(bb));

    String res = "";

    int temp;

    int sub = 0;

    String ch = "";

    if (a.length() < b.length() || (a.compareTo(b) < 0)) {//正数

    String c = a;

    a = b;

    b = c;

    ch = "-";

    for (int i = a.length() - 1, j = b.length() - 1; i > -1 || j > -1; ) {

    if (i > -1 && j > -1) {

    int tempA = a.charAt(i--) - '0' + sub;

    sub = 0;

    int tempB = b.charAt(j--) - '0';

    if (tempA < tempB) {

    sub = -1;

    temp = tempA + 10 - tempB;

    } else {

    temp = tempA - tempB;

    } else if (i > -1) {

    temp = (a.charAt(i--) - '0') + sub;

    sub = 0;

    } else {

    temp = (b.charAt(j--) - '0') + sub;

    sub = 0;

    res = temp + res;

    //高位去0

    int spilt = 0;

    for (int i = 0; i < res.length(); i++) {

    if (res.charAt(i) - '0' != 0) {

    break;

    } else {

    spilt++;

    res = res.substring(spilt);

    System.out.println("结果=" + ch + res);

    乘法和加法类似,但是因为涉及到累计相加的过程(模拟算术做竖式乘法的过程),所以结合数组更加方便理解一些

    private static void multiply(String a, String b) {

    System.out.println("乘法===");

    BigInteger ba = new BigInteger(a);

    BigInteger bb = new BigInteger(b);

    System.out.println("结果=" + ba.multiply(bb));

    int as[] = new int[a.length()];

    int bs[] = new int[b.length()];

    for (int i = 0; i < a.length(); i++) {

    as[i] = a.charAt(a.length() - i - 1) - '0';

    for (int i = 0; i < b.length(); i++) {

    bs[i] = b.charAt(b.length() - i - 1) - '0';

    int res[] = new int[b.length() + a.length()];

    for (int i = 0; i < a.length(); i++) {

    int adv = 0;

    int j;

    for (j = 0; j < b.length(); j++) {

    res[i + j] = as[i] * bs[j] + adv + res[i + j];

    adv = res[i + j] / 10;

    res[i + j] = res[i + j] % 10;

    res[i + j] = adv;

    int len = a.length() + b.length() - 1;

    if (res[len] == 0) len--;

    System.out.printf("结果=");

    for (int i = len; i >= 0; i--) {

    System.out.printf(res[i] + "");

    主函数:

    public class Test {

    public static void main(String[] args) {

    Scanner scanner = new Scanner(http://System.in);

    System.out.println("输入a");

    String a = "";

    if (scanner.hasNext())

    a = scanner.next();

    System.out.println("输入b");

    String b = "";

    if (scanner.hasNext())

    b = scanner.next();

    add(a, b);

    sub(a, b);

    multiply(a, b);

    好了,以上就是今天的分享内容了,今天的知识你学到了吗?没学到没关系我们每天都会为大家分享。

    展开全文
  • 高精度运算(大数运算)

    千次阅读 2020-03-24 03:36:31
    高精度运算是指参与运算的数远大于标准数据类型的数,动辄成百上千位的数。所以高精度数又被称为大数。 本文主要讲解:大数加法,大数减法,大数乘法,大数除法,大数阶乘。 java的大数类做这一类题很方便,效率高...
  • 基于ansistring类型开发了delphi7的高精度计算单元high.dcu,其中包含高精度加法、减法、乘法、除法、最小公倍数、最大公约数 等计算函数或过程。其接口文件如下: unit high; interface const intmax=32767; ...
  • js高精度计算

    千次阅读 2019-01-10 16:04:57
    //其它运算类似,就可以得到比较精确的结果。 //减法函数 function Subtr(arg1, arg2) { var r1, r2, m, n; try { r1 = arg1.toString().split(".")[1].length } catch (e) { r1 = 0 } try { r2 = arg2....
  • 高精度运算(C语言)

    2012-10-07 14:23:48
    高精度运算 (C语言)
  • 高精度计算出S=1!+2!+3!+…+n!(n≤50),其中“!”表示阶乘,例如:5!=5×4×3×2×1。 输入正整数n,输出计算结果S。 格式 输入格式 一个正整数n。 输出格式 计算结果S。 样例 输入样例 5 输出样例 ...
  • C语言笔记:高精度计算问题

    千次阅读 多人点赞 2019-10-24 16:03:10
    文章目录C语言中大数据类型的简述高精度加法 C语言中大数据类型的简述 我们知道,计算机内部直接使用int或者double等数据类型存储数据是有范围限制的,当运算数据较大时,计算机将会出现溢出情况,使得计算结果...
  • 美国家半导体公司(National Semiconductor Corporation)宣布推出两款全新的高精度运算放大器。高精度运算放大器的特点具有很低的输入电压噪声和较高的准确度,因此适用于以低频及低供电电压操作的系统,例如工业和...
  • 这个版本的高精度整数库不仅支持高精度高精度,同时修复了减法...并支持高精度类型与其他一切可转换为高精度类型的类型(int,long long,unsignd,string)进行混合运算。同时,全面优化了除法、取余计算的时间复杂度。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 308,456
精华内容 123,382
关键字:

高精度运算

友情链接: stm8-C++.zip