当前位置:首页 >> 学科竞赛 >>

高精度计算


高精度运算
昌邑一中 闫昭斐

引例
【试题描述】 已知两个正整数a和b。求a、b的和。 【样例输入】 999 99 【样例输出】 要求1:a、b的范围:0—30000

程序如下: var a,b,c:integer; begin read(a,b); c:=a+b; writeln(c) end.

/>1098
要求2:a、b的范围:0—2000000000

var

a,b:longint;

要求3:a、b的范围:0—9000000000000000000

Var

a,b:qword;

总 结
要求4:a、b的范围:0—10000000000000000000 exitcode=106

exitcode=201
出错原因:

a、b、c的数值范围超出了标准数据类型“整型”所规 定的范围!

Pascal语言中的数值型数据类型
整型
类型 Byte Shortint Integer Word Longint 0..255 -128..128 -32768..32767 0..65635 -2147483648..2147483647 值域 长度(字节) 1 1 2 2 4

Longword
QWord

0..4294967295
0..18446744073709551615

4
8

Int64

-9223372036854775808..9223372036854775807

8

Pascal语言中的数值型数据类型
实型
类型
Real Single Duble Comp

值域
10-38..1038 1.5*10-45..3.4*1038 5.0*10-324..1.7*10308 -9.2*1018..9.2*1018

长度(字节)
6 4 8 8

Extended

1.9*10-4951..1.1*104932

10

总 结
? 整型和实型,都是有限的范围;

? 程序所处理的各类型数据必有相应的值域限定。
? 如果待处理的数据很大,就如引例中一样,位

数达到几十甚至上千位,大大超出了所定义标 准类型规定的范围,此时结果就会出错。这是 由现有计算机的软硬件条件限制所决定的。 ? 那么如何解决这个问题呐? 可在程序设计中使用高精度运算。

高精度运算?
? 所谓的高精度运算,是指在某些问题中,参与处

理的数据大小超出了标准数据类型所能表示的范 围的运算。 ? 高精度运算是信息学奥赛中用到的最基础的知识 之一,单独考察的情形很少出现,但作为基础知 识,在考察其他主要算法时会经常用到,且常出 现在难度较高的题目中,并因其处理时的高复杂 度,使许多选手望而却步。 ? 高精度运算对选手的编程技巧和程序调试能力提 出了很高的要求。并要求选手非常细心的去对待 他。

常见的高精度运算:
? 加法运算 ? 减法运算 ? 乘法运算 ? 除法运算

高精度运算涉及到的主要操作:
? 数据的输入和存储
? 数据的运算
加、减、乘、除运算 加法和乘法的进位 减法的借位和符号确定 除法商和余数的处理

? 数据的输出

加法运算
已知两个正整数a和b(<10200),求a、b的和。 【分析】 1、数据的输入和存储 2、计算结果的位数 3、加法计算与进位 4、结果的输出

1、数据的输入和存储
? 数据超出标准类型(整型、实型)所能表示的范围,不能直接定义。我们

考虑利用现有的某些标准类型来间接实现数据的输入和存储。分析发现: 在Pascal中,能表示多位数的数据类型有两种:数组和字符串。 ? 数组:每个数组元素可以存储数的1位(注意此处可优化),操作数有 多少位就需要开辟多少个数组元素的数组。 优点:每一位都是数的形式,可以直接加减;运算时非常方便。 缺点:数组不能直接输入;输入时每两位数之间必须有分隔符,不 符合数值的输入习惯; ? 字符串:String型字符串的最大长度是255,可以表示255位。Ansistring 型字符串长度不受限制。 优点:能直接输入输出,输入时,每两位数之间不必分隔符,符合 数值的输入习惯; 缺点:字符串中的每一位是一个字符,不能直接进行运算,必须先 将它转化为数值再进行运算;运算时非常不方便;

总结
? 字符串可以将“数”作为“串”直接输入,但

不能对“数串”直接进行加减等运算; ? 数组不能将“数”直接输入,却可以实现每个 数组元素存储“数”的1位,这样数组每一位 都是数的形式,可以直接进行运算。 对上面两种数据结构取长补短: 我们采用数串(字符串)形式输入数据, 并将其转化为数组来存储,就解决了高精度的 数据输入和存储问题。

示例:已知两个正整数a和b(<10200),求a、b的和。
1、数据的输入。 字符串输入: Var sa,sb:string; 程序: Readln(sa); Readln(sb); 2、数据的存储 数组存储: Var a,b:array[1..200] of integer; 程序: la:=length(sa); for i:= 1 to la do a[i]:=ord(sa[la+1-i])-48; lb:=length(sb); for i:= 1 to lb do b[i]:=ord(sb[lb+1-i])-48;

? 在这里,用数组a存数串sa,数组b存数串sb。为了便于以后的计算

和进位处理,在数组a中,我们用a[1]存储数的个位,数组b也一样。 ? 如输入的数为3452345:

示例:已知两个正整数a和b(<10200),求a、b的和。
如上面的题目,其输入和存储可以这样来实现: const max=200; var a,b,:array [1..max] of integer; //a,b用于存储 sa,sb:string; // “数串”sa和sb,用于输入 la,lb,i:integer;//la为数串sa的长度和lb为sb的长度 程序: readln(sa); readln(sb); //输入数串sa和sb la:=length(sa); //求数串sa的长度 for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord('0'); //将数串sa分离并存储到a中 lb:=length(sb); //求数串sb的长度 for i:= lb downto 1 do b[lb-i+1]:=ord(sb[i])-ord('0');//将数串sb分离并存储到b中

2、计算结果的位数
? 在高精度运算中,要先确定计算结果的位数,以确定存放计算结

果的数组的大小。 ? 加法运算中,结果的位数最大等于两数中较大数的位数+1, 如:987+65,结果1052 123+45,结果168 加数和被加数的最大位数为3 结果的位数为4或3 注意要考虑到加法的最高位可能有进位。 若把计算结果存到数组c中, 则var c:array[1..max+1] of integer;

3、加法计算与进位
? 分析发现,实际上高精度加法运算的过程,就是

模拟手工加法竖式运算的过程。
①运算顺序:两运算数右对齐;从低位向高位运算;

1 2 3 4 + 5 6 7 8 -----------6 9 1 2

②运算规则:同一位的两个数相加再加上从低位来的进位, 成为该位的和;这个和去掉向高位的进位就成为该位的值;

③最后一位的进位:如果完成两个数的相加后, 进位位值不为0,则应添加一位;

a[max]…a[i]…a[2] a[1] + b[max]…b[i]…b[2] b[1] ___________________________________ c[max+1] c[max]…c[i]…c[2] c[1]

3、加法计算与进位
? 在这里我们采用先计算后进位的方法。
⑴如果两个加数位数不一样多,则按位数多的一个进行计算; ⑵运算顺序:两运算数右对齐;从低位向高位运算; ⑶运算规则: 同一位的两个数相加,如果不考虑进位, 直接运算的的话,c[i]:=a[i]+b[i]。 ⑷然后进行进位处理:若c[i]>=10,则 c[i]:=c[i]-10; c[i+1]:=c[i+1]+1; 我们可借助MOD、DIV运算来实现。
a[max]…a[i]…a[2] a[1] + b[max]…b[i]…b[2] b[1] ___________________________________ c[max+1] c[max]…c[i]…c[2] c[1]

3、加法计算与进位
具体如下: if la>lb then len:=la else len:=lb; for i:=1 to len do c[i]:=a[i]+b[i]; //直接进行加法计算 for i:=1 to len do //进位处理 begin c[i+1]:=c[i+1]+c[i] div 10; //向前进位 c[i]:=c[i] mod 10; //当前位 end;

4、结果的输出
加法运算要注意最高位的输出。 if c[len+1]>0 then len:=len+1; //若最高位有进位,则c的长度为len+1 for i:=len downto 1 do write(c[i]); //输出结果
a[max]…a[i]…a[2] a[1] + b[max]…b[i]…b[2] b[1] ___________________________________ c[max+1] c[max]…c[i]…c[2] c[1]

5、“计算与进位”的过程的优化
改进1:c=a+b,边计算边处理进位。
for i:=1 to len do begin c[i+1]:=(a[i]+b[i]+c[i]) div 10; c[i]:=(a[i]+b[i]+c[i]) mod 10; end;
1 2 3 4

+ 5 6 7 8
------------

6 9 1 2

5、“计算与进位”的过程的优化
改进2:a=a+b,计算结果直接存储在数组a中, 不再定义数组c,减少了存储空间。 for i:=1 to len do begin a[i+1]:=a[i+1]+(a[i]+b[i]) div 10; a[i]:=(a[i]+b[i]) mod 10; end.

【参考程序】 const max=200; var sa,sb:string; b:array[1..max] of integer; a:array[1..max+1] of integer; len,la,lb, i:integer; begin readln(sa); readln(sb); //数据输入 fillchar(a,sizeof(a),0); fillchar(b,sizeof(b),0); //数组初始化 la:=length(sa); lb:=length(sb); for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord('0'); //数据存储 for i:= lb downto 1 do b[lb-i+1]:=ord(sb[i])-ord('0'); //数据存储 if la>lb then len:=la else len:=lb; for i:=1 to len do begin a[i+1]:=a[i+1]+(a[i]+b[i]) div 10; //计算与进位同时处理,结果放在a中 a[i]:=(a[i]+b[i]) mod 10; end; if a[len+1]>0 then len:=len+1; for i:=len downto 1 do write(a[i]); //结果输出 writeln end.

总 结
? 加法运算:先确定a和b两数的最大位数

len(max{la,lb})。然后依照由低位至高位(第1 位至第len位)的顺序进行加法运算。在每一次位 运算中,a当前位加b当前位的和除以10,其整商 即为进位,其余数即为和的当前位。在进行了len 位的加法后,输出时要注意,若最高位有进位 (a[len+1]≠0),则a的长度为len+1。 ? 数组使用前一般都要初始化: Fillchar(a,sizeof(a),0)。 ? 当输入数据较大,超出string型的最大长度是255 位,要使用Ansistring型。

随堂练习
? Fibonacci数列 :有雌雄一对兔子,假定过两个

月后便每个月可繁殖雌雄各一的一对小兔子。问 过n个月后共有多少对兔子? 要求1:n<=93。 要求2:n<=1000。
? 计算s=1+2+3+….+n。(n>=10 ) ? n个100位左右的数相加. 规定n为2到5之间。
20

Fibonacci数列 (N<=93)解析
F(i):第i个月后共有的兔子对数。 {N<=93} F(1)=1; var f:array[1..100] of qword; F(2)=1; var n,i:integer; begin f(3)=2; readln(n); f(4)=3; f[1]:=1; f[2]:=1; f(5)=5; for i:=3 to n do f[i]:=f[i-2]+f[i-1]; f(6)=8;
F(i)=f(i-2)+f(i-1)
writeln(f[n]); end.

n比较小, 不必用高精度!

Fibonacci数列 (N<=1000)解析
{N<=1000} var n,len,i,k:integer; f1,f2,f:array[1..210] of integer; begin fillchar(f1,sizeof(f1),0); fillchar(f2,sizeof(f2),0); readln(n); f1[1]:=1; F2[1]:=1; len:=1;
for k:=3 to n do begin fillchar(f,sizeof(f),0); for i:=1 to len do begin f[i+1]:=(f1[i]+f2[i]+f[i]) div 10; f[i]:=(f1[i]+f2[i]+f[i]) mod 10; end; if f[len+1]>0 then len:=len+1; f1:=f2; f2:=f; end; writeln(len); for i:=len downto 1 do write(f[i]); end.

题目:n个100位左右的数相加. 规定n为2到5之间
const n=5;m=150;{n为加数的个数,m为加数的位数} var s:array[1..n] of string;{字符串型一维数组} a:array[1..n,1..m] of integer;{二维数组} c:array[1..m] of integer;{放答案的一维数组} i,j,ca,n1:integer;{i,j变量,ca是进位,n1是加数个数} begin fillchar(c,sizeof(c),0); readln(n1);{读入加数的个数} for i:=1 to n1 do readln(s[i]);{把加数读进字符串数组里} for i:=1 to n do for j:=1 to length(s[i]) do a[i,j]:=ord(s[I,length(s[i])-j+1])-48; {把个位放到第一个位置,依次放好,数字等于字符-48}

ca:=0; for j:=1 to m do begin for i:=1 to n1 do c[j]:=c[j]+a[i,j]; {每次都加所有个(十/百/千)位里的数,故加了一次,进位清零} c[j]:=c[j]+ca; ca:=c[j] div 10; c[j]:=c[j] mod 10; end; i:=m; while c[i]=0 do i:=i-1; {因为最高位放的个位,所以倒过来输出,且去掉前面的N个0} for j:=i downto 1 do write(c[j]); end.

高精度减法
? 已知两个正整数a和b(<10
【分析】
200

),求a、b的差。

1、输入与存储 2、计算结果的位数 3、确定差的符号 4、减法计算与借位 5、结果的输出

1、输入与存储
? 减法的输入与存储同“加法运算”是一样的。
1、数据的输入。 字符串输入: Var sa,sb:string; 程序: Readln(sa); Readln(sb); 2、数据的存储 数组存储: Var a,b:array[1..200] of integer; 程序: la:=length(sa); for i:= 1 to la do a[i]:=ord(sa[la+1-i])-48; lb:=length(sb); for i:= 1 to lb do b[i]:=ord(sb[lb+1-i])-48;

2、计算结果的位数
? 减法的计算结果的位数最大等于两数中较大数的

位数

54321 656 -----------53865

3、确定差的符号
如何判断被减数与减数的大小:字符串知识 ? 我们要求a-b,并利用sa、sb来读入a、b,要确定 a-b的符号,只有比较sa和sb的大小。 ? 若sa>sb,结果为正数; ? 若sa=sb,结果为0; ? 若sa<sb,结果为负数。在程序实现上,要用一个 变量来存储符号位'-',且交换sa和sb,使sa>sb, 以保证sa-sb>0。 ? 当我们确定差的符号后,后面只需计算sa-sb的值 即可。

怎么判断sa和sb两个数串(字符串)的大小呐?
? 可以从两串长度是否相等的角度考虑。

if (length(sa)<length(sb)) or ((length(sa)=length(sb))and(sa<sb)) then begin fh:='-'; s:=sa; sa:=sb; sb:=s; end;

怎么判断sa和sb两个数串(字符串)的大小呐?
? 在短串前补0,使两串等长后再比较大小
将两个字符串的位数补成一样(因为字符串的比较是从左边对齐 的;两个字符串一样长才能真正地比较出大小):短的在左边补0 (1) 补0。 la:=length(sa); lb:=length(sb); if la>lb then for i:=1 to la-lb do sb:='0'+sb else for i:=1 to lb-la do sa:='0'+sa; (2)接着比较大小:直接比较字符串大小。 fh:=''; if sa<sb then begin fh:='-';s:=sa; sa:=sb; sb:=s; end;

4、减法计算与借位
? 大数减小数——判断结果符号是已确定 ? 借位——在进行减法运算的过程中,当被减数的某位小于减数的

对应位时,为了保证够减,要考虑借位的问题。具体如下: if a[i]<b[i] then begin //借位 a[i+1]:=a[i+1]-1; a[i]:=a[i]+10; end; a[i]:=a[i]-b[i]; //减法运算

54321
456

------------

53865

实际上,高精度减法运算的过程,也是模拟手工减法竖式运算的过程。

4、减法计算与借位
关于计算与借位,还可以这样运算: i:=1; while (i<=la)or(i<=lb) do begin x:=a[i]-b[i]+10+x; //不考虑大小问题,先往高位借10 a[i]:=x mod 10; //存储第i位的值 x:=x div 10-1; //将高位借掉的1减去} i:=i+1; end;

5、结果的输出
? 我们将结果存储于数组a,最后输出a即可,若结

果是负数,要输出符号位。 ? 先找到差的第一个非零数,如果差的所有位数都 为零,就直接输出零。
while (a[len]=0)and(len>1) do len:=len-1;//寻找输出的位置 if fh='-' then write(fh); //结果的符号 for i:=len downto 1 do write(a[i]); //结果输出

【参考程序】 ---------------------------------const max=200; var s,sa,sb:string; a,b:array[1..max] of integer; len,la,lb, i:integer; fh:char; //用于表示差的符号 begin readln(sa); readln(sb); //数据读入 if sa=sb then begin writeln(0);halt;end; //被减数=减数的情形 if (length(sa)<length(sb))or ((length(sa)=length(sb))and(sa<sb)) then begin fh:=‘-’; s:=sa; sa:=sb; sb:=s; end; //比较两数大小, 判断差的符号 la:=length(sa); lb:=length(sb); fillchar(a,sizeof(a),0); fillchar(b,sizeof(b),0); //初始化数组 for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord('0');//数据存储 for i:= lb downto 1 do b[lb-i+1]:=ord(sb[i])-ord('0');//数据存储

len:=la;
for i:=1 to len do begin if a[i]<b[i] then begin a[i+1]:=a[i+1]-1; a[i]:=a[i]+10; end; a[i]:=a[i]-b[i]; //减法计算 end; //借位

while a[len]=0 do len:=len-1;
if fh='-' then write(fh);

//寻找输出的位置
//结果输出

//结果的符号

for i:=len downto 1 do write(a[i]);

writeln;
end.

总 结
? 减法运算:比较sa和sb的大小,如果sa=sb(即

被减数=减数),则结果为0;如果sa>sb,结果 为正数,如果sa<sb,结果为负数,置符号位fh 为'-',并交换sa、sb。将sa存于数组a,sb存 于数组b。置len=la,依照由低位至高位(第1 位至第len位)的顺序进行减法运算,结果存于 数组a。在每一次位运算中,当a[i]<b[i]时, 要先借位,再计算。最后输出时要注意先确定 输出的位置,同时不要忘记结果的符号。

高精度乘法
? 高精度乘以单精度

大数 * 小数 ? 高精度乘以高精度 大数 * 大数

1、高精度乘以单精度
已知两个正整数a和b(a<10200,b<108),求a、b的 乘积。
【分析】 (1)输入与存储 (2)计算结果的位数 (3)乘法计算与进位 (4)结果的输出

(1)输入与存储
? 单精度数可直接读入:readln(b); ? 高精度数的输入与存储同“加法运算”,

为了便于以后的计算和进位处理,在数组a中, 我们 仍然用a[1]存储数的个位。 readln(sa); //读入被乘数
la:=length(sa); fillchar(a,sizeof(a),0); //初始化数组 for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord('0'); //存储被乘数于数组a

(2)计算结果的位数
? 乘法运算的结果的位数最大等于两数位数的和。

999 999 ------------

998001

(3)乘法计算与进位
? 采用的策略可以先算乘法,然后处理进位。

? 按照乘法的规则,从a[1]到a[la] 逐位与b相乘
? 进位处理:

a[i]:=a[i] +a[i-1] div 10; a[i-1]:=a[i-1] mod 10。

a[6] a[5] a

[a4] ……..

a[1]

1
78

2

3

4

5

6

b

(4)结果的输出
? 注意不要漏掉最高位的处理,乘法的最高位可能

有进位,进位可能不止一位。
c:=a[la+1]; while c<>0 do //处理最高位的进位 begin inc(la); a[la]:=c mod 10; c:=c div 10; end;

【参考程序】 const max=200; var sa:string; //被乘数 i,la:integer; b,c:longint; //b是乘数,c用于处理最高位的进位 a:array[1..max+8] of longint; //用于存储被乘数sa和最后运算的结果 begin readln(sa); //读入被乘数 readln(b); //读入乘数 if (sa='0')or(b=0) then begin writeln(0);halt;end; la:=length(sa); fillchar(a,sizeof(a),0); //初始化数组 for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord('0'); //存储被乘数于数组a

for i:=1 to la do for i:=1 to la do begin

a[i]:=a[i]*b; //先进行乘法运算,数组a逐项乘以数b //处理进位,从低位开始逐项处理 //高位a[i+1]的进位为低位a[i] div 10

a[i+1]:=a[i+1]+a[i] div 10; a[i]:=a[i] mod 10;

//进位后,a[i]的值为对10的余数

end;
c:=a[la+1]; while c<>0 do //处理最高位的进位

begin
inc(la); a[la]:=c mod 10;

c:=c div 10;
end; for i:=la downto 1 do write(a[i]); //结果的输出

end.

2、高精度乘以高精度
已知两个正整数a和b(a<10200,b<10200),求a、b的 乘积。
【分析】 (1)输入与存储 (2)计算结果的位数 (3)乘法计算与进位 (4)结果的输出

(1)输入与存储
? 高精度数的输入与存储同“加法运算”。

1、数据的输入。 字符串输入: Var sa,sb:string; 程序: Readln(sa);

2、数据的存储 数组存储: Var a,b:array[1..200] of integer; 程序: la:=length(sa); for i:= 1 to la do a[i]:=ord(sa[la+1-i])-48; lb:=length(sb); for i:= 1 to lb do b[i]:=ord(sb[lb+1-i])-48;

Readln(sb);

(2)计算结果的位数
? 乘法运算的结果的位数最大等于两数位数的和。

跟前面一样!!

(3)乘法计算与进位
? 我们来模拟手工乘法竖式运算的过程。

(3)乘法计算与进位
我们仍然可以先处理乘法运算: c[i+j-1]:=c[i+j-1]+a[i]*b[j]; 然后再处理进位: c[i+1]:=c[i+1]+c[i] div 10; c[i]:=c[i] mod 10;

(4)结果的输出
? 同“高精度乘以单精度”一样 ? 注意不要漏掉最高位的处理。

【参考程序】 const max=200; var sa,sb:string; x:longint; a,b:array[1..max] of integer; //用于存储sa,sb c:array[1..2*max] of integer; //用于存储计算结果 i,j,la,lb,len:integer; begin readln(sa); readln(sb); //数据输入 if (sa='0')or(sb='0') then begin writeln(0);halt;end; fillchar(a,sizeof(a),0); //初始化数组a fillchar(b,sizeof(b),0); //初始化数组b fillchar(c,sizeof(c),0); //初始化数组c la:=length(sa); for i:= la downto 1 do a[la-i+1]:=ord(sa[i])-ord(‘0’); //数据存储 lb:=length(sb); for i:= lb downto 1 do b[lb-i+1]:=ord(sb[i])-ord('0'); //数据存储

for i:=1 to la do for j:=1 to lb do c[i+j-1]:=c[i+j-1]+a[i]*b[j]; //先直接进行乘法运算 len:=la+lb; for i:=1 to len do //进位处理 begin c[i+1]:=c[i+1]+c[i] div 10; c[i]:=c[i] mod 10; end; while c[len]=0 do dec(len); //寻找现最高位的位置 x:=c[len]; while x>0 do //处理最高位的进位 begin c[len]:=x mod 10; x:=x div 10; inc(len); end; for i:=len-1 downto 1 do write(c[i]) //输出结果 end.

高精度除法
? 高精度除以单精度 ? 高精度除以高精度


相关文章:
高精度运算(C++)
万进制高精度运算( ++语言) 万进制高精度运算(C++语言) 语言目前在青少年信息学奥林匹克竞赛中所涉及到的高精度计算包括加(addition)、减(subtract)、乘 (...
高精度计算
高精度计算朴素高精度由于待处理的数据超过了任何一种数据类型所能容纳的范围, 因此必须采用数串形式输 入, 并将其转化为数组。 该数组的每一个元素对应一个十...
高精度算法报告
高精度算法研究秦雪洋,廖福轩,吴韩,顾仁杰,楼嘉豪 (陕西师范大学 计算机科学学院,陕西 西安 710062) 摘要: 文章中对“高精度四则运算”进行了分析,对四则运算...
高精度算法大全
对于高精度数,也要像平常数一样做加减乘除以及乘方的运算,于是就有了 高精度算法: 由于计算机输入计算结果的精度通常受到计算机的限制,如:在双精度方式 下,计算机...
高精度计算
高精度计算_计算机软件及应用_IT/计算机_专业资料。关于计算机中的高精度的讲解 高精度计算 由于计算机具有运算速度快,计算精度高的特点,许多过去由人来完成的烦 琐...
第四讲 高精度计算
授课教师:滨海县实验小学仇大成 small_jiajia@163.com 第四讲 高精度计算 由于计算机具有运算速度快,计算精度高的特点,许多过去由人来完成的烦琐、复杂的 数学计算...
高精度运算
高精度运算_IT/计算机_专业资料。PASCAL 程序设计基本方法 第二讲 高精度运算(加法) 高精度运算(加法) 一、高精度加法运算学习中级本书上的 P180 页到 183 页...
高精度计算c
竞赛辅导 3---高精度计算 高精度计算在利用计算机进行数值计算时,如果对数值的要求在允许范围内,可以利用数值型数据进行存储, 数值范围较大,计算精度要求较高,就需...
高精度运算模板
高精度运算模板_物理_自然科学_专业资料。<高精度> #include <stdio.h> #include <string.h> #include <memory.h> #define M 10000 #define len 31000 <高...
c语言大作业高精度计算
c语言大作业高精度计算_计算机软件及应用_IT/计算机_专业资料。学班学姓 摘要 院级号名 编写一个程序实现 A+B 和 A*B,但是 A 和 B 都超出了 C 语言数 ...
更多相关标签:
高精度计算 c语言 | 高精度运算 | 高精度 | 高精度乘法 | 高精度计算器 | c++高精度计算 | pascal高精度计算 | 高精度加法 |