任意精度计算C语言源代码

最新推荐文章于 2024-05-23 09:52:11 发布
最新推荐文章于 2024-05-23 09:52:11 发布
阅读量979 收藏 2
点赞数 1
文章标签： 任意精度计算 高精度计算 模拟人脑计算 源代码 可演算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shu27s/article/details/80297707
版权

我想通过模拟人的计算方式，了解人工智能或意识。编了几个函数。它能任意精确度计算，纯C代码。

禁止用于商业目的。

plus.h

#ifndef __PLUS_H__
#define __PLUS_H__
#ifdef __cplusplus 
extern "C" {
#endif 
 char* xunhuanAll(char*chh1,char*chh2,char ch);
 void xunhuan1(char *chh2, char chh, int n);
 char* xunhuanplus(char *chh1, char *chh2);
 char* clrspchr(char * str); // 删除str中全部空白字符
 char* limltnum(char *str);
 char* xunhuansubtract(char *chh1, char *chh2);
 char* xunhuanmultiply(char *chh1, char *chh2);
 char* xunhuandivided(char *chh1, char *chh2, char k, char l, char dot1, char dot2);
 void xunhuansubtract1(char *chh2, char chh, int n);
 void xunhuanmultiply1(char *chh2, char chh, int n);
 void xunhuandivided1(char *chh2, char chh, int n);
 char* shuym(char*str);//输入输出口

#ifdef __cplusplus 
}
#endif 

#endif

//

plus.cpp

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <ctype.h>
#include "plus.h"
#define lonng 300
/*char* xunhuanAll(char*chh1, char*chh2, char ch);
void xunhuan1(char *chh2, char chh, int n);
char* xunhuanplus(char *chh1, char *chh2);
char* clrspchr(char * str); // 删除str中全部空白字符
char*  limltnum(char *str);
char* xunhuansubtract(char *chh1, char *chh2);
char* xunhuanmultiply(char *chh1, char *chh2);
char* xunhuandivided(char *chh1, char *chh2, char k, char l, char dot1, char dot2);
void xunhuansubtract1(char *chh2, char chh, int n);
char* shuym(char*str);*/


char suanshu[600] = { "0+0=0;0+1=1;0+2=2;0+3=3;0+4=4;0+5=5;0+6=6;0+7=7;0+8=8;0+9=9;\
       1+1=2;1+2=3;1+3=4;1+4=5;1+5=6;1+6=7;1+7=8;1+8=9;1+9=10;\
       2+2=4;2+3=5;2+4=6;2+5=7;2+6=8;2+7=9;2+8=10;2+9=11\
       3+3=6;3+4=7;3+5=8;3+6=9;3+7=10;3+8=11;3+9=12;\
       4+4=8;4+5=9;4+6=10;4+7=11;4+8=12;4+9=13;\
       5+5=10;5+6=11;5+7=12;5+8=13;5+9=14;\
       6+6=12;6+7=13;6+8=14;6+9=15;\
       7+7=14;7+8=15;7+9=16;\
       8+8=16;8+9=17;\
       9+9=18;" };

char shengfa[600] = { "0*0=0;0*1=0;0*2=0;0*3=0;0*4=0;0*5=0;0*6=0;0*7=0;0*8=0;0*9=0;\
       1*1=1;1*2=2;1*3=3;1*4=4;1*5=5;1*6=6;1*7=7;1*8=8;1*9=9;\
       2*2=4;2*3=6;2*4=8;2*5=10;2*6=12;2*7=14;2*8=16;2*9=18;\
       3*3=9;3*4=12;3*5=15;3*6=18;3*7=21;3*8=24;3*9=27;\
       4*4=16;4*5=20;4*6=24;4*7=28;4*8=32;4*9=36;\
       5*5=25;5*6=30;5*7=35;5*8=40;5*9=45;\
       6*6=36;6*7=42;6*8=48;6*9=54;\
       7*7=49;7*8=56;7*9=63;\
       8*8=64;8*9=72;\
       9*9=81;" };

//

plus.cpp

char * xunhuanplus(char *chh1, char *chh2){
 int k = strlen(chh1); k = k - 1; int j = k, j1 = 0, booa = 0;
 char chh11[7] = {}, chh22[7] = {}, plus[2] = {}, multiply[2] = {};
 strcpy(plus, "+");

 while (k + 1> 0){
  if (chh2[k] == '.')k = k - 1;
  chh11[0] = 'w';
  chh11[0] = chh1[k]; chh11[1] = '\0';
  chh22[0] = chh2[k]; chh22[1] = '\0';

  /判断高位是否全为零

  while (j >= 0 && !booa){

   if (chh2[j] != '0' || chh1[j] != '0'){
    j1 = j - 1;//因循环倒一‘0‘；倒二非‘0’的最后一次。

   }

   if (j == 0)booa = 1;
   j--;
  };
  if (booa && k == j1){

   break;
  }
  //
  if (chh11[0] < chh22[0]){
   strcat(chh11, plus); strcat(chh11, chh22);
  }
  else
  {
   strcat(chh22, plus); strcat(chh22, chh11);
   strcpy(chh11, chh22);
  }
  int i = 0;
  while (1)
  {

   if (!strncmp(suanshu + i, chh11, 3)){
    chh22[0] = suanshu[i + 4];

    if (suanshu[i + 5] != ';'){
     chh22[1] = suanshu[i + 5];
     chh22[2] = '\0'; break;
    }
    if (suanshu[i + 5] == ';'){

     chh22[1] = '\0'; break;
    }
   };
   if (suanshu[i] == '\0')break;
   i++;
  }

  if (chh22[1] == '\0'){
   chh2[k] = chh22[0]; chh22[0] = '0';
  }
  if (chh22[1] != '\0'){
   chh2[k] = chh22[1]; chh22[1] = '0';;
   xunhuan1(chh2, chh22[0], k);
  }
  k--;
 };


 return chh2;
}
void xunhuan1(char *chh2, char chh, int n){
 char chh1[lonng] = {}, chh4[lonng] = {}, chh3[lonng] = {},
  chh11[5] = {}, chh22[5] = {}, plus[2] = { '+' };


 int i = 0, k = n, j = k, j1 = 0, booa = 0;
 while (k > 0){
  chh11[0] = chh; chh11[1] = '\0'; chh = 0;
  if (chh2[k - 1] == '.')k = k - 1;
  chh22[0] = chh2[k - 1]; chh22[1] = '\0';

  /判断高位是否全为零
  while (j >= 0 && !booa){

   if (chh2[j] != '0' || chh1[j] != '0'){
    j1 = j - 2;//因循环倒一‘0‘；倒二非‘0’的最后一次。

   }

   if (j == 0)booa = 1;
   j--;
  };
  if (booa && k == j1){
   break;
  }

  //
  if (chh11[0] < chh22[0]){
   strcat(chh11, plus); strcat(chh11, chh22);
  }
  else
  {
   strcat(chh22, plus); strcat(chh22, chh11);
   strcpy(chh11, chh22);
  }
  i = 0;
  while (1)
  {
   if (!strncmp(suanshu + i, chh11, 3)){
    chh22[0] = suanshu[i + 4];

    if (suanshu[i + 5] != ';'){
     chh22[1] = suanshu[i + 5];
     chh22[2] = '\0'; break;
    }
    if (suanshu[i + 5] == ';'){
     chh22[1] = '\0'; break;
    }
   };
   if (suanshu[i] == '\0')break;
   i++;
  }


  k = k - 1;
  if (chh22[1] == '\0'){
   chh2[k] = chh22[0]; chh22[0] = '0'; return;
  }
  if (chh22[1] != '\0'){
   chh2[k] = chh22[1]; chh22[1] = '0';

   xunhuan1(chh2, chh22[0], k);
  }

  k--;
 }
}

char* clrspchr(char * str)
{
 for (char*s = str, *p = str; (isspace(*s) || '\b' == *s) ? *s++ : (*p++ = *s++);) continue;
 return str;
}

char* limltnum(char *str){//只允许数字及+—*/ 进入

 int i = 0, f = 0, a = -2, b = 0;
 char chstr[10] = {}, shun[10] = {}, str1[10000] = {}; memset(chstr, 'x', sizeof(char) * 10);
 while (1){

  if (str[i] >= '0' &&str[i] <= '9' || str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '.' || str[i] == '\0')
  {
   if (str[i] == '+'){ shun[f++] = '+'; if (a != i - 1){ a = i; }; b = i; }
   if (str[i] == '-'){ shun[f++] = '-'; if (a != i - 1){ a = i; }; b = i; }
   if (str[i] == '*'){ shun[f++] = '*'; if (a != i - 1){ a = i; }; b = i; }
   if (str[i] == '/'){ shun[f++] = '/'; if (a != i - 1){ a = i; }; b = i; }
   if (str[i] == '\0'){ break; }

  }
  else{
   chstr[0] = '0'; return chstr;
  }

  if (a == b - 1){ chstr[0] = '0'; return chstr; }
  i++;
 }

 if (str[0] == '-'&&shun[1] == '*'){ shun[0] = '*'; shun[2] = '-'; }
 if (str[0] == '-'&&shun[1] == '/'){ shun[0] = '/'; shun[2] = '-'; }
 if (str[0] == '-' && (shun[1] == '+' || shun[1] == '-' || shun[1] == '*' || shun[1] == '/')){
  strcpy(str1, str + 1); strcpy(str, str1);
 }
 chstr[0] = shun[0];  chstr[1] = shun[1]; chstr[2] = shun[2]; chstr[9] = '\0';
 if (f == 0)chstr[0] = '0';

 return  chstr;
}
///

char * xunhuansubtract(char *chh1, char *chh2){

 int k = 0, ka = strlen(chh1), j = k, j1 = 0, booa = 0, booanegative = 0, booamultiple = 0, i = 0;
 char chh11[7] = {}, chh22[7] = {}, chh3[lonng] = {}, chh4[lonng] = {};
 //f (strlen(chh1) != strlen(chh2))
 if (strlen(chh1) != strlen(chh2)){
  ka = strlen(chh1); k = strlen(chh2); chh4[0] = '\0'; chh3[0] = '\0';
  if (ka > k){
   while (1){
    if (i++ >= ka - k)break; strcat(chh4, "0");
   }
  }
  else{
   while (1){
    if (i++ >= k - ka)break; strcat(chh4, "0");
   }
  }
  if (ka > k){
   strcat(chh4, chh2); strcpy(chh2, chh4);

  }
  else{
   strcat(chh4, chh1); strcpy(chh1, chh4);

  }
  ka = strlen(chh1);
 }
 strcpy(chh4, chh1); k = ka - 1; i = 0;
 while (k + 1 > 0){
  booanegative = 0, booamultiple = 0;
  if (chh2[k] == '.')k = k - 1;
  chh11[0] = chh4[k]; chh11[1] = '\0';
  chh22[0] = chh2[k]; chh22[1] = '\0';
  /判断高位是否全为零
  while (j >= 0 && !booa){

   if (chh2[j] != '0' || chh1[j] != '0'){
    j1 = j - 1;//因循环倒一‘0‘；倒二非‘0’的最后一次。

   }

   if (j == 0)booa = 1;
   j--;
  };
  if (booa && k == j1){
   break;
  }
  //

  //加数      被加数t
  if (chh22[0]>chh11[0]){
   booanegative = 1;
   if ((chh22[0] - '0' + chh22[0] - '0') >= ('9' - '0' + chh11[0] - '0' + '1' - '0')){
    //用零表示未知数

    strcpy(chh3, "0+");
    strcat(chh3, chh22);
    strcat(chh3, "=1");
    strcat(chh3, chh11);
    strcpy(chh11, chh3);


   }
   else{
    strcat(chh22, "+0=1"); strcat(chh22, chh11); strcpy(chh11, chh22);
    booamultiple = 1;
   }

  }
  else
  {

   if ((chh22[0] - '0' + chh22[0] - '0') >= (chh11[0] - '0')){

    strcpy(chh3, "0+");
    strcat(chh3, chh22);
    strcat(chh3, "=");
    strcat(chh3, chh11);
    strcpy(chh11, chh3);

   }
   else{
    booamultiple = 1;

    strcat(chh22, "+0="); strcat(chh22, chh11); strcpy(chh11, chh22);//用零表示未知数
   }

  }

  int i = 0;
  while (1)
  {

   if (booamultiple&&!booanegative&&!strncmp(suanshu + i, chh11, 2) && !strncmp(suanshu + i + 3, chh11 + 3, 2) ||//用于1+0＝7模式
    booamultiple&&booanegative&&!strncmp(suanshu + i, chh11, 2) && !strncmp(suanshu + i + 3, chh11 + 3, 3) ||//用于1+0＝17模式
    !booamultiple&&!booanegative&&!strncmp(suanshu + i + 1, chh11 + 1, 4) ||//用于0+4＝7模式
    !booamultiple&&booanegative&&!strncmp(suanshu + i + 1, chh11 + 1, 5)//用于0+6＝11模式
    ){
    if (booamultiple){

     chh4[k] = suanshu[i + 2]; break;
    }
    if (!booamultiple){

     chh4[k] = suanshu[i]; break;
    }

   };
   if (suanshu[i] == '\0')break;
   i++;
  }


  if (booanegative){

   strcpy(chh1, chh4); chh11[0] = '1';//用于上一位减一。
   xunhuansubtract1(chh1, chh11[0], k); strcpy(chh4, chh1);
  }

  k--;
 }

 //


 strcpy(chh1, chh4);

 return chh1;
}
void xunhuansubtract1(char *chh1, char chh, int n){
 char chh2[lonng] = {}, chh4[lonng] = {}, chh3[lonng] = {},
  chh11[7] = {}, chh22[7] = {};
 int i = 0, k = n, booamultiple = 0, booanegative = 0, j = k, j1 = 0, booa = 0;

 while (k  > 0){

  if (chh1[k - 1] == '.')k = k - 1;
  chh22[0] = chh; chh22[1] = '\0'; chh = '0'; chh11[0] = '0';
  chh11[0] = chh1[k - 1]; chh11[1] = '\0';

  if (chh22[0] == '0')break;

  //加数      被加数t
  if (chh22[0]>chh11[0]){
   booanegative = 1;
   if ((chh22[0] - '0' + chh22[0] - '0') >= ('9' - '0' + chh11[0] - '0' + '1' - '0')){
    //用零表示未知数

    strcpy(chh3, "0+");
    strcat(chh3, chh22);
    strcat(chh3, "=1");
    strcat(chh3, chh11);
    strcpy(chh11, chh3);


   }
   else{
    strcat(chh22, "+0=1"); strcat(chh22, chh11); strcpy(chh11, chh22);
    booamultiple = 1;
   }

  }
  else
  {

   if ((chh22[0] - '0' + chh22[0] - '0') >= (chh11[0] - '0')){

    strcpy(chh3, "0+");
    strcat(chh3, chh22);
    strcat(chh3, "=");
    strcat(chh3, chh11);
    strcpy(chh11, chh3);

   }
   else{
    booamultiple = 1;

    strcat(chh22, "+0="); strcat(chh22, chh11); strcpy(chh11, chh22);//用零表示未知数
   }

  }

  i = 0;
  while (1)
  {

   if (booamultiple&&!booanegative&&!strncmp(suanshu + i, chh11, 2) && !strncmp(suanshu + i + 3, chh11 + 3, 2) ||//用于1+0＝7模式
    booamultiple&&booanegative&&!strncmp(suanshu + i, chh11, 2) && !strncmp(suanshu + i + 3, chh11 + 3, 3) ||//用于1+0＝17模式
    !booamultiple&&!booanegative&&!strncmp(suanshu + i + 1, chh11 + 1, 4) ||//用于0+4＝7模式
    !booamultiple&&booanegative&&!strncmp(suanshu + i + 1, chh11 + 1, 5)//用于0+6＝11模式
    ){
    if (booamultiple){

     chh1[k - 1] = suanshu[i + 2];

     break;
    }
    if (!booamultiple){

     chh1[k - 1] = suanshu[i];

     break;
    }

   };
   if (suanshu[i] == '\0')break;
   i++;
  }

  if (booanegative){
   k = k - 1;
   chh11[0] = '1';用于上一位减一。
   xunhuansubtract1(chh1, chh11[0], k);
  }
  k--;
 }
}


char* xunhuanmultiply(char *chh1, char *chh2){

 int ka = strlen(chh1), i = 0, i1 = 0, ii1 = 0, k = 0, j = 0, j1 = 0, booa = 0, k1 = 0
  , jj = 0, jj1 = 0, booaa = 0;
 char chh4[lonng] = {}, chh3[lonng] = {};
 char chh11[7] = {}, chh22[7] = {}, plus[2] = { '*' };

 if (strlen(chh1) != strlen(chh2)){
  ka = strlen(chh1); k = strlen(chh2); chh4[0] = '\0'; chh3[0] = '\0';
  if (ka > k){
   while (1){
    if (i++ >= ka - k)break; strcat(chh4, "0");
   }
  }
  else{
   while (1){
    if (i++ >= k - ka)break; strcat(chh4, "0");
   }
  }
  if (ka > k){
   strcat(chh4, chh2); strcpy(chh2, chh4);

  }
  else{
   strcat(chh4, chh1); strcpy(chh1, chh4);

  }
  ka = strlen(chh1);
 }

 ///
 memset(chh4, '0', sizeof(char) * lonng); memset(chh3, '0', sizeof(char) * lonng);
 chh3[lonng - 1] = '\0'; chh4[lonng - 1] = '\0';
 k1 = ka - 1;
aa: k = ka - 1; //因‘0‘


 while (k + 1 > 0){
  if (chh1[k] == '.')k = k - 1;
  if (chh2[k1] == '.')k1 = k1 - 1;
  chh11[0] = 'w';
  chh11[0] = chh1[k]; chh11[1] = '\0';
  chh22[0] = chh2[k1]; chh22[1] = '\0';

  /判断高位是否全为零
  j = k;
  while (j >= 0 && !booa){

   if (chh1[j] != '0'){
    j1 = j - 1;//因循环倒一‘0‘；倒二非‘0’的最后一次。
   }

   if (j == 0)booa = 1;
   j--;
  };
  if (booa && k == j1){
   break;
  }
  jj = k1;
  while (jj >= 0 && !booaa){

   if (chh2[jj] != '0'){
    jj1 = jj - 1;//因循环倒一‘0‘；倒二非‘0’的最后一次。
   }

   if (jj == 0)booaa = 1;
   jj--;
  };
  if (booaa && k1 == jj1){
   k1 = 0; break;
  }
  //
  if (chh11[0] < chh22[0]){
   strcat(chh11, plus); strcat(chh11, chh22);
  }
  else
  {
   strcat(chh22, plus); strcat(chh22, chh11);
   strcpy(chh11, chh22);
  }

  int i = 0;
  while (1)
  {

   if (!strncmp(shengfa + i, chh11, 3)){
    chh22[0] = shengfa[i + 4];

    if (shengfa[i + 5] != ';'){
     chh22[1] = shengfa[i + 5];
     chh22[2] = '\0';

     i1 = i1 + 2;
     chh4[lonng - 1 - i1] = chh22[0]; chh4[lonng - 1 - i1 + 1] = chh22[1]; chh4[lonng - 1] = '\0';

     if (chh22[0] != '0' || chh22[1] != '0') xunhuanplus(chh4, chh3);

     chh4[lonng - 1 - i1] = '0'; chh4[lonng - 1 - i1 + 1] = '0'; i1 = i1 - 1;//加法位移
     break;
    }
    if (shengfa[i + 5] == ';'){


     i1 = i1 + 1;
     chh4[lonng - 1 - i1] = chh22[0];
     chh4[lonng - 1] = '\0';
     if (chh22[0] != '0')xunhuanplus(chh4, chh3);
     chh4[lonng - 1 - i1] = '0';//加法位移
     chh22[1] = '\0'; break;
    }

   };


   if (shengfa[i] == '\0')break;
   i++;
  }

  k--;
 }
 //i1 =++ii1;//乘法位移

 if (k1-- > 0){ i1 = ++ii1;   goto aa; }//用于乘法双循环。
 while (1){//去除前置

  if (chh3[0] != '0' || chh3[0] == '0'&&chh3[1] == '.' || chh3[0] == '0'&&chh3[1] == '\0')break;
  if (chh3[0] == '0'&&chh3[1] != '.'){ strcpy(chh2, chh3 + 1); strcpy(chh3, chh2); }
 }

 return chh3;
}

char* xunhuandivided(char *chh1, char *chh2, char k, char l, char dot1, char dot2)
{

 int dotdevided = 0, booaBCHouYi = 0, dot = 0, booa = 0, i = 0, i1 = 0, end = 0, booaend = 1, booazero = 0, BCHouYi = 0;//被除后移
 char chh3[lonng] = {}, chh4[lonng] = {}, chh55[lonng] = {}, chh6[lonng] = {}, chh7[lonng] = {}, chh8[lonng] = {};

 if (dot2 > 1){//消除dot2
  strncpy(chh4, chh2, l); strcat(chh4, chh2 + l + 1); strcpy(chh2, chh4); l = l + dot2 - 1;
  while (1){
   if (dot2 == 1)break;
   if (dot1 > 1){
    if (chh1[k + 1] == '\0')chh1[k + 1] = '0';
    if (!booa)strncpy(chh4, chh1, k); booa = 1; chh4[k] = chh1[k + 1]; chh4[k + 1] = '\0';  chh1[k + 1] = chh1[k]; //dot1移动

    k++;
   }


   if (dot1 == 0){
    if (!booa)strcpy(chh4, chh1); booa = 1; chh4[k] = '0'; chh4[k + 1] = '\0';
    k++;
   }

   dot2--;
  }
  if (dot1 > 1){ strcat(chh4, chh1 + k); strcpy(chh1, chh4); };

  chh4[k] = '\0';
  if (dot1 == 0)strcpy(chh1, chh4);
 }
 strcpy(chh4, chh1); memset(chh1, 0, sizeof(char) * lonng);
 while (1){//去除前置'0'

  if (chh2[0] != '0' || (chh2[0] == '0'&&chh2[1] == '.') || chh2[0] == '0'&&chh2[1] == '\0')break;
  if (chh2[0] == '0'&&chh2[1] != '.'){ strcpy(chh8, chh2 + 1); strcpy(chh2, chh8); k--; }
 }
 l = strlen(chh2);

 
 i1 = 0;
aa: i = 0;
 i1 = strlen(chh3);
 booa = 0;
 if (chh4[0] == '0'&&chh4[1] == '.'&&end == 0){ i = i + 1; }//对0.n的0，进行跳过。
 while (1){  //装入数组
  if (chh4[i] == '.'){ i = i + 1; booaBCHouYi = 1;  dot = 1; }
  if (chh4[i] == '\0' || booazero){ booazero = 1; chh4[i] = '0'; dot = 1; }
  chh3[i1] = chh4[i];//
  if (booaBCHouYi || booazero){ BCHouYi++; if (!dot)dotdevided++; };
  i++; i1++; if (strlen(chh3) - 1 >= l - 1)break;//被除数与除数位数同。
 }
 chh3[i1] = '\0'; strcpy(chh7, chh4 + i); strcpy(chh4, chh7);


 

 i = 0; i1 = 0; booa = 0;
 strcpy(chh6, chh2);
bb:
 itoa(i1, chh55, 10);
 strcpy(chh7, chh6);//备用

 while (1){//去除前置'0'

  if (chh3[0] != '0' || (chh3[0] == '0'&&chh3[1] == '.') || chh3[0] == '0'&&chh3[1] == '\0')break;
  if (chh3[0] == '0'&&chh3[1] != '.'){ strcpy(chh8, chh3 + 1); strcpy(chh3, chh8); k--; }
 }
 strcpy(chh6, xunhuanmultiply(chh2, chh55));//减数乘以i倍，再比较。
 i = 0; booa = 0;



 while (1){
  if (strlen(chh6)>strlen(chh3)){ booa = 1; break; }
  if (strlen(chh6)<strlen(chh3)){ booa = 0; break; }
  if (chh6[i] >= chh3[i]){
   if (chh6[i] > chh3[i]){ booa = 1; break; }
   if (chh6[i] == chh3[i] && chh6[i] == '\0'){ booa = 1; strcpy(chh7, chh6); i1 = i1 + 1; break; }
  }
  else break;

  i++;
 }
 if (!booa){ i1++; goto bb; }
 strcpy(chh8, chh3);

 if (booa){ strcpy(chh3, xunhuansubtract(chh3, chh7)); }//小于被减数chh3的，且最接近的。


 /输出处理
 if (dot && booaend){  //'.'前加‘0‘
  while (1){

   if (dotdevided-- <= 0) break;
   BCHouYi-- <= 1; chh1[end++] = '0';
  }

 } dotdevided = 0;//被除后移
 if (dot&&booaend){
  if (!end){
   chh1[end++] = '0'; chh1[end++] = '.'; booaend = 0;
   if (BCHouYi > 1){
    while (1){

     if (BCHouYi-- <= 1)break;  chh1[end++] = '0';
    }
   } //被除后移

  }
  else{
   chh1[end++] = '.'; booaend = 0;
   if (BCHouYi > 1){
    while (1){ if (BCHouYi-- <= 1)break;  chh1[end++] = '0'; }
   } booaBCHouYi = 1;//被除后移

  }
 }
 if (BCHouYi > 1){
  while (1){ if (BCHouYi-- <= 1)break;  chh1[end++] = '0'; }
 } booaBCHouYi = 1;//被除后移
 chh1[end++] = char(i1 - 1 + '0'); chh1[end] = '\0'; BCHouYi = 0;

 if (end<lonng / 2) goto aa;
 return chh1;
}

char* shuym(char*strshu){ //参数在函数体过程中改变，其传入的实际参数相应改变。

剩余源代码可下载。

















































shu27s
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言编写一个计算器（附全源代码）
web15286201346的博客
06-02 3110
这个计算器其实是我老师布置的一个c语言大作业，捉摸着搞了那么久的东西不能浪费了吧，于是我分享下我的代码和大概思路 给个关注点个赞，后续我会分享更多我们学生党的作业问题白嫖党们先看代码，我就先上上全代码，干！ 前言： 为了达到目的，首先自学了栈：按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除
C语言sizeof的计算方式
Brand_J的博客
04-04 4090
对于C语言开发人员来说，sizeof应该不陌生吧。此次我主要写的是sizeof对各变量长度的计算方式。sizeof这个函数主要是对各数据类型的长度进行计算，入参为数据类型，返回值计算结果。但由于不同OS的系统架构下，sizeof计算的结果会存在一定的差异。下文主要基于32位系统，讨论sizeof的计算方式。比较常见的场景是基本数据类型长度的计算结果如下：类型32位系统(bytes)64位系统(by...
《C语言接口与实现》实验——任意精度算数（Calc）
dijkstar的专栏
04-01 2070
《C语言接口与实现》书中P235示例，源码在： #include #include #include #include #include "include/stack.h" #include "include/ap.h" #include "include/fmt.h" #pragma comment(lib, "libcii.lib") Stack_T sp
C语言 计算器实现
bolife的博客
10-16 935
实现可以快速增加算法的计算器，便捷更改/增加计算方法。
推荐项目：Malachite - 高精度算术库
最新发布
gitblog_00045的博客
05-23 293
推荐项目：Malachite - 高精度算术库 项目地址:https://gitcode.com/mhogrefe/malachite 1、项目介绍 Malachite 是一个专为Rust编程语言设计的高精度算术库，它支持任意精度的整数运算，并且正在开发浮点数（目前处于实验阶段）。这个库深受著名数学软件GMP、FLINT和MPFR的影响，旨在提供高效且可靠的高精度计算解决方案。Malachite...
码题集——高精度计算（C语言附源码）
jingjingjing1023的博客
05-28 782
二.分析 1.整型可以表示的范围-2^15——2^15-1，显然数据范围超出了整型可以表示的范围
C语言实现任意精度除法,任意精度整数除法，如何处理32位余数？
weixin_39893205的博客
05-21 534
Brendan..5那个算法太可怕了。第一步应该是确定结果的符号(从分子和除数的符号开始)；然后找到分子和除数的大小(并为“分子为0”和“ abs(除数)为0或1”的捷径，在这种情况下，实际上可以避免或不可能进行除法操作)，以便执行实际的除法仅处理正数。第二步应该是确定除数是否小到足以容纳一位数字(数字的基数是您的语言/环境支持的最大底数-例如，对于32位整数的C，它可能是“基数” 65536”，...
C高精度算法
m0_73599738的博客
12-14 1855
大整数
任意精度计算源代码
05-13
在本主题中，我们将深入探讨C语言实现的任意精度计算，以及如何通过编程模拟人脑的思维过程。 在C语言中实现任意精度计算通常涉及到自定义的数据结构，如链表或数组，来存储和操作大数。这些数据结构能够容纳任意...
arb：用于任意精度球运算的C库
01-30
arb库是一个专为进行任意精度球运算的C语言库，主要设计用于处理高精度浮点数计算、线性代数、特殊函数、复数运算、多精度计算以及浮点区间算术等领域。这个库的核心特点是提供了高效且精确的数学运算，以支持在不...
BigDigits:BigDigits多精度算术源代码-Big source code
03-25
《BigDigits：深入理解大型数字计算的开源库》 ...BigDigits库，正如其名，专注于提供高效且灵活的多精度算术运算，...对于想要深入了解大数计算或者寻求此类功能的人来说，BigDigits的源代码是一个不可多得的学习资源。
C语言最小二乘法多项式拟合
02-15
用C语言实现多项式的拟合，采用最小二乘法，数据精度在e-13数量级，拟合循环最大次数为50。matlab默认精度e-9，。
高精度计算（c语言实现）
07-29
关于高精度的基本运算，包括加减乘除和阶乘，是用c语言实现的，绝对的好东西
高精度算法全集（C语言）
05-07
高精度算法全集（C语言）包括高精度加法减法，高精度乘以高精度，高精度除以高精度……
C语言高精度浮点计算代码
04-05
【问题描述】 计算 k *∑(x^i), －m ≤ i ≤ n，精确到小数点后14位（最后要求四舍五入）。 【输入形式】 从文件sigma.in中顺序读入4个由空格分隔的正整数k、x、m、n。(1≤ k、x、m、n ≤ 100)。 【输出形式】 将结果写到标准输出，其中小数占14位，不足部分补零，最后输出一个回车。(输入数据保证输出结果小于2^53。) 【输入样例】 1 10 5 5 【输出样例】 111111.11111000000000
C++实现pi的任意精度计算
11-19
这是一份关于π的任意精度计算的C++实现源代码.算法是基于二次收敛算法,即AGM(几何平均数)方法,该算法也可应用于计算椭圆积分和以先进的ADI算法实现椭圆偏微分方程. (速度可能优于Mathematica!!!)
GNU的大数运算库，可以进行任意精度计算
07-13
GNU大数运算库，全称为GNU Multiple Precision Arithmetic Library（GMP），是一个开源的C语言库，专门为需要进行高精度计算的程序设计者提供服务。它允许开发者处理超过标准整型和浮点型所能表示的数值范围，实现了...
任意精度的小数运算
Mine268的博客
10-11 526
任意精度的小数运算 问题的大致内容如下 给定正整数 n,m,k(n<m)n,m,k(n<m)n,m,k(n<m)，求 n/mn/mn/m 的值，保留 kkk 位小数。 这道题的我分为两步解决 计算 n/mn/mn/m 的任意位小数； 通过计算的结果构建链表或类似循环链表的结构； 根据链表或类似循环链表的结构输出。 计算任意精度的小数 有穷小数 重温除法的竖式计算过程，本质上是整除与取余数的过程，在除法的每一步中商作为结果对应位的数，余数乘以十后作为下一步的被除数。以 2/72/72
学生成绩管理系统C源代码
10-13
源代码中的注释详细描述了每个功能的实现细节，对于学习C语言编程以及开发类似系统的人来说，具有很大的帮助。 总之，学生成绩管理系统是一款功能强大的C语言程序，可以帮助学校或教育机构更高效地管理学生的成绩...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值