高精度运算文档格式.docx
《高精度运算文档格式.docx》由会员分享，可在线阅读，更多相关《高精度运算文档格式.docx（15页珍藏版）》请在冰豆网上搜索。
//函数介绍：
在字符数组s中适当位置插入符号'
（'
voidInsert（chars[],intleft,intright）;
判断当前余数是否与前面的某个余数相同，若相同，返回该余数的位置下标
intIsCycle（chara[][MAX],intlabel）;
利用字符串实现超长整型，高精度除法阶乘运算
voidFactorial（char*base,char*result）;
利用字符串实现超长整型，高精度乘方运算
voidIntPower（char*base,char*exponential,char*power）;
利用字符串实现超长浮点型，高精度乘方运算，注意指数为整数
voidFloatPower（char*base,char*exponential,char*power）;
intmain（void）
{
chara[MAX]={0};
charb[MAX]={0};
charc[3*MAX]={0};
chard[MAX]={0};
puts（"
请输入第一个数：
"
）;
gets（a）;
请输入第二个数：
gets（b）;
IntAddition（a,b,c）;
两者之和：
）;
puts（c）;
IntSubtration（a,b,c）;
两者之差：
puts（c）;
IntMultiplication（a,b,c）;
两者之积：
IntDivision（a,b,c,d）;
两者之商：
余数：
puts（d）;
IntPower（a,b,c）;
两者之乘方：
Factorial（a,c）;
a的阶乘：
system（"
pause"
return0;
}
voidIntAddition（char*augend,char*addend,char*sum）
intcAug[MAX]={0};
//用来存储被加数的整型数组
intcAdd[MAX]={0};
//用来存储加数的整型数组
intcSum[MAX]={0};
//用来存储两数之和的整型数组
intlenAug=strlen（augend）,lenAdd=strlen（addend）;
//被加数和加数字符串的长度
intlenMin=lenAug<
lenAdd?
lenAug:
lenAdd;
//两个加数的长度中的较小值
inti;
//逆序复制加数和被加数到整型数组（因为加法运算是从低位开始）
for（i=0;
i<
lenAug;
i++）
cAug[i]=augend[lenAug-1-i]-'
0'
;
lenAdd;
cAdd[i]=addend[lenAdd-1-i]-'
intcarry=0;
//进位
ints=0;
//两数之和
lenMin;
i++）//加法运算过程
s=cAug[i]+cAdd[i]+carry;
//两个加数和进位之和作为当前位的和
cSum[i]=s%10;
//存储当前位
carry=s/10;
//获取进位
}
//处理加数或被加数超出长度lenMin的部分
while（i<
lenAug）
s=cAug[i]+carry;
i++;
lenAdd）
s=cAdd[i]+carry;
if（carry>
0）//处理最后一个进位
cSum[i++]=carry;
intj;
for（j=0;
j<
i;
j++）//逆序存储两数之和到字符串sum
sum[j]=cSum[i-1-j]+'
sum[i]='
\0'
intCompare（constchar*a,constchar*b）
intlenA=strlen（a）;
intlenB=strlen（b）;
if（lenA!
=lenB）
returnlenA>
lenB?
1:
-1;
else
returnstrcmp（a,b）;
voidIntSubtration（char*minuend,char*subtrahend,char*difference）
if（strcmp（minuend,subtrahend）==0）//如果两数相等，返回"
0"
strcpy（difference,"
return;
intcM[MAX]={0};
//用来存储被减数的整型数组
intcS[MAX]={0};
//用来存储减数的整型数组
intcD[MAX]={0};
//用来存储两数之差的整型数组
intlenM=strlen（minuend）,lenS=strlen（subtrahend）;
//被减数和减数字符串的长度
intlenMin=lenM<
lenS?
lenM:
lenS;
//两个减数的长度中的较小值
intflag;
//记录结果是整数还是负数
//逆序复制减数和被减数到整型数组（因为减法运算是从低位开始），保证cM大于cS
if（Compare（minuend,subtrahend）>
0）
flag=0;
//被减数大于减数，结果为正数
for（i=0;
lenM;
cM[i]=minuend[lenM-1-i]-'
lenS;
cS[i]=subtrahend[lenS-1-i]-'
flag=1;
//被减数小于减数，结果为负数，此时要用subtrahend-minuend
cS[i]=minuend[lenM-1-i]-'
cM[i]=subtrahend[lenS-1-i]-'
i++）//减法运算过程
if（cM[i]>
=cS[i]）//被减数大于减数，直接相减
cD[i]=cM[i]-cS[i];
else//否则要向前借位
{
cD[i]=cM[i]+10-cS[i];
--cM[i+1];
}
//处理减数或被减数超出长度lenMin的部分
intlen=lenM>
len）
=0）
cD[i]=cM[i];
else
cD[i]=cM[i]+10;
while（cD[i-1]==0）
i--;
intj=0;
if（flag==1）//如果被减数小于减数，返回一个负数
difference[j++]='
-'
intk;
for（k=i-1;
k>
=0;
k--,j++）//逆序存储两数之差到字符串sum
difference[j]=cD[k]+'
difference[j]='
voidIntMultiplication（char*multiplicand,char*multiplier,char*product）
//用来存储被乘数的整型数组
intcR[MAX]={0};
//用来存储乘数的整型数组
intcP[MAX]={0};
//用来存储两数之乘积的整型数组
chartcP[MAX]="
intlenD=strlen（multiplicand）,lenR=strlen（multiplier）;
//被乘数和乘数字符串的长度
inti,j,k;
//逆序复制乘数和被乘数到整型数组（因为乘法运算是从低位开始）
lenD;
cD[i]=multiplicand[lenD-1-i]-'
lenR;
cR[i]=multiplier[lenR-1-i]-'
intcarry;
intmul=0;
//两数之乘积
strcpy（product,"
//先使product的值为0
i++）//乘法运算过程
carry=0;
for（j=0;
j++）//乘数的每一位都和被乘数进行乘法运算
mul=cD[j]*cR[i]+carry;
//两个乘数之积与进位相加作为当前位乘积
cP[j]=mul%10;
carry=mul/10;
if（carry>
0）//获取最后一个进位
cP[j++]=carry;
while（cP[j-1]==0）//去掉多余的0
--j;
//逆序复制当前位的乘积tP到字符串tcP
for（k=0;
k<
j;
k++）
tcP[k]=cP[j-1-k]+'
j++）//注意各位数得到的结果应相应左移
tcP[k++]='
tcP[k]='
IntAddition（product,tcP,product）;
//对字符串进行加法运算
voidIntDivision（char*dividend,char*divisor,char*quotient,char*remainder）
if（Compare（dividend,divisor）==0）//被除数等于除数
strcpy（quotient,"
1"
strcpy（remainder,"
return;
if（strcmp（divisor,"
）==0||Compare（dividend,divisor）<
0）//被除数小于除数
strcpy（remainder,dividend）;
charbuf[2]="
//临时数组依次存储被除数的每一位数
inti,s,k;
strcpy（remainder,"
//先使product的值为空
for（i=0,k=0;
dividend[i]!
='
s=0;
buf[0]=dividend[i];
strcat（remainder,buf）;
//接上被除数的一位数，改变当前余数
while（Compare（remainder,divisor）>
=0）//连减试商
s++;
IntSubtration（remainder,divisor,remainder）;
quotient[k++]=s+'
//记录每一位得到的商值
if（strcmp（remainder,"
）==0）
//使product的值为空，去掉多余的0
quotient[k]='
//去掉多余的0
quotient[i]=='
;
for（j=i;
=k;
j++）
quotient[j-i]=quotient[j];
Radix（char*toStr,char*fromStr）
inti=0,j=0;
intlen;
while（fromStr[i]!
='
.'
&
&
fromStr[i]!
）
toStr[j++]=fromStr[i++];
len=i++;
//跳过小数点，并记录该位置
returni-len-1;
//记录小数点后的数字个数
voidFloatAddition（char*augend,char*addend,char*sum）
charcAug[MAX]={0};
//用来存储被加数的字符串
charcAdd[MAX]={0};
//用来存储加数的字符串
charcSum[MAX]={0};
//用来存储两数之和的字符串
intlenAug,lenAdd,lenSum;
//分别存储三个数的小数点后的数字个数
inti,topAug,topAdd;
//去掉小数点，把浮点数转化成整数后存储到新的字符串
lenAug=Radix（cAug,augend）;
lenAdd=Radix（cAdd,addend）;
topAug=strlen（cAug）;
topAdd=strlen（cAdd）;
//在小数部分较短的字符串后补零，使得两个数的小数部分长度相等
if（lenAug>
lenSum=lenAug;
for（i=lenAug-lenAdd;
i>
0;
i--）
cAdd[topAdd++]='
lenSum=lenAdd;
for（i=lenAdd-lenAug;
cAug[topAug++]='
cAdd[topAdd++]='
cAug[topAug++]='
//执行整数加法运算
IntAddition（cAdd,cAug,cSum）;
i=strlen（cSum）-1;
while（lenSum>
0&
cSum[i]=='
）//去掉小数部分多余的零
lenSum--;
cSum[i+2]='
0）//在适当位置插入'
.’
cSum[i+1]=cSum[i];
cSum[i+1]='
strcpy（sum,cSum）;
voidFloatSubtration（char*minuend,char*subtrahend,char*difference）
charcM[MAX]={0};
//用来存储被减数的字符串
charcS[MAX]={0};
//用来存储减数的字符串
charcD[MAX]={0};
//用来存储两数之差的字符串
intlenM,lenS,lenD;
inti,topM,topS;
lenM=Radix（cM,minuend）;
lenS=Radix（cS,subtrahend）;
topM=strlen（cM）;
topS=strlen（cS）;
if（lenM>
lenS）
lenD=lenM;
for（i=lenM-lenS;
cS[topS++]='
lenD=lenS;
for（i=lenS-lenM;
cM[topM++]='
cM[topM++]='
cS[topS++]='
//执行整数减法运算
IntSubtration（cM,cS,cD）;
i=strlen（cD）-1;
while（lenD>
cD[i]=='
lenD--;
cD[i+2]='
cD[i+1]=cD[i];
cD[i+1]='
if（i==-1）//结果为0的情况
cD[0]='
cD[1]='
cD[2]='
strcpy（difference,cD）;
voidFloatMultiplication（char*multiplicand,char*multiplier,char*product）
//用来存储被乘数的字符串
charcR[MAX]={0};
//用来存储乘数的字符串
charcP[2*MAX]={0};
//用来存储两数之乘积的字符串
intlenD,lenR,lenP;
lenD=Radix（cD,multiplicand）;
lenR=Radix（cR,multiplier）;
lenP=lenD+lenR;
IntMultiplication（cD,cR,cP）;
inti=strlen（cP）-1;
while（lenP>
cP[i]=='
lenP--;
cP[i+2]='
i>
=0）//在适当位置插入'
升级会员 