落叶高精度表达式计算器v1.0版

落叶

谢谢你的分析，源码，帮我从另一个角度理解表达式解析，等我回来用vc调试理解理解。
我的乘方和阶乘的判断错了，是因为我为每个运算符都定义了一个运算等级，把乘方理解为单操数运算符了，所以把它和阶乘的等级定为同级，现重新定义了等级，问题已经解决。
对于连续乘方应该是从左向右，还是从右向左，国内几个表达式计算器也是从左向右算的，具体数学上是怎么定义的，我不清楚，所以我暂时没有调整，但如何从右向左算乘方，目前我也想到了解决办法。假如老外是对的，我再改过来。

happysxyf

落叶 发表于 2017-1-3 14:55
谢谢你的分析，源码，帮我从另一个角度理解表达式解析，等我回来用vc调试理解理解。
我的乘方和阶乘的判断 ...

好的，我一直都是按照老外的优先级来的，因为那样在解决一些数学问题时很有优势。
对了，那个代码只适合gcc编译器，VC需要小改一下。逆波兰是速度最快的算法，也是内存占用最小的。
为了省事，我全部用了双目运算，即使是sin之类的也是用伪双目模拟的，这样做节省了一半代码。

落叶

happysxyf 发表于 2017-1-3 16:47
好的，我一直都是按照老外的优先级来的，因为那样在解决一些数学问题时很有优势。
对了，那个代码只适 ...

数字帝国的表达式计算，乘方也是从右向左算，老外的是对的，我的计算器已改过来，1.1版加上批处理和赋值语句后一起更新。
你用过我的ABC公式，算式存取功能吗？我想把它取消，全部用赋值语句存储，不知道那种方法更易用？例：用A=3+5;    代替现在的算式存入功能。

另外你的代码质量很高，看的很舒服易懂，写码速度远超过我，你写码有二年了吧？或天赋太强？

happysxyf

落叶 发表于 2017-1-5 14:48
数字帝国的表达式计算，乘方也是从右向左算，老外的是对的，我的计算器已改过来，1.1版加上批处理和赋 ...

我是新手，自学C语言才半年。我的是在批处理中就直接支持批量计算，可以每秒计算1000万行。
这改是我的进版，增加了错误反馈，速度比前面的代码提升10倍左右。

1. 
   
2. /*
   
3.     REVERSE POLISH EXPRESSION CALCULATOR, COPYRIGHT@2017~2019 BY HAPPYSXYF
   
4.     REVPOLISH.EXE
   
5.     VERSION 1.6
   
6. */
   
7. 
   
8. #include   <stdio.h>
   
9. #include   <ctype.h>
   
10. #include    <math.h>
    
11. #include <windows.h>
    
12. 
    
13. /***************定义宏变量***************/
    
14. //堆栈尺寸
    
15. #define  STACK_SIZE   1024
    
16. //帮助说明
    
17. #define HELPINFORMATION "\
    
18. REVERSE POLISH EXPRESSION CALCULATOR,COPYRIGHT@2017~2019 BY HAPPYSXYF\n\
    
19. -----------------------------------------------------------------\n\
    
20. revpolish [expression]\n\
    
21. -----------------------------------------------------------------\n\
    
22. FUNCTIONS:\n\
    
23.     pi=3.1415926535897932, e=2.7182818284590452\n\
    
24.     +, -, *, /, %, ^, !\n\
    
25.     round, floor, ceil, exp, deg, sqrt, abs, lg, ln\n\
    
26.     sin, cos, tan, arcsin, arccos, arctan\n\
    
27.     sinh, cosh, tanh, arcsinh, arccosh, arctanh\n\
    
28. -----------------------------------------------------------------\n\
    
29. 2017-01-05  VERSION 1.6\n"
    
30. 
    
31. /***************全局类变量***************/
    
32. //数学函数关键词
    
33. static const char* KEY_WORDS[]={"e", "pi", "sqrt", "lg", "ln", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "deg", "abs", "round", "floor", "ceil", "exp", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", NULL};
    
34. //运算符栈
    
35. char   STACK1[STACK_SIZE]={0};
    
36. //逆波兰栈
    
37. char   STACK2[STACK_SIZE]={0};
    
38. //浮点数栈
    
39. double STACK3[STACK_SIZE]={0};
    
40. 
    
41. /***************功能函数类***************/
    
42. //阶乘函数
    
43. long long fact(long long n)
    
44. {
    
45.     return (n<2) ?1 :n*(fact(n-1));
    
46. }
    
47. //逆波兰核心
    
48. double RevPolishCore(const char* expression)
    
49. {
    
50.         char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;
    
51.         double *S3=STACK3, di, ni;
    
52.        
    
53.         //生成逆波兰       
    
54.         while(*op!='\0'){               
    
55.                 switch(*op){
    
56.                 case ' ' :
    
57.                 case '\t':
    
58.                 case '\r':
    
59.                 case '\n':
    
60.                         //过滤空字符
    
61.                         op++;
    
62.                         continue;
    
63. 
    
64.                 case 'a':
    
65.                 case 'b':
    
66.                 case 'c':
    
67.                 case 'd':
    
68.                 case 'e':
    
69.                 case 'f':
    
70.                 case 'g':
    
71.                 case 'h':
    
72.                 case 'i':
    
73.                 case 'j':
    
74.                 case 'k':
    
75.                 case 'l':
    
76.                 case 'm':
    
77.                 case 'n':
    
78.                 case 'o':
    
79.                 case 'p':
    
80.                 case 'q':
    
81.                 case 'r':
    
82.                 case 's':
    
83.                 case 't':
    
84.                 case 'u':
    
85.                 case 'v':
    
86.                 case 'w':
    
87.                 case 'x':
    
88.                 case 'y':
    
89.                 case 'z':
    
90.                         //识别数学函数关键词
    
91.                         key=(char**)KEY_WORDS;
    
92.                         while(*key !=NULL){       
    
93.                                 cp=op, kp=*key;
    
94.                                 //比对关键词字母
    
95.                                 while(*cp==*kp && *kp!='\0'){
    
96.                                         cp++, kp++;
    
97.                                 }
    
98.                                 //验证关键词结尾
    
99.                                  if((*cp<'a'||*cp>'z') && (*kp=='\0')){
    
100.                                          op=cp;
     
101.                                         break;
     
102.                                 }
     
103.                                 key++;
     
104.                         }
     
105.                         //构建伪双目
     
106.                         if(*key !=NULL){                               
     
107.                                 *(S2++)='.';
     
108.                                 *(S2++)=' ';
     
109.                                 //伪双目入栈
     
110.                                 while('A'<=(*S1) && (*S1)<='Z'){
     
111.                                         *(S2++)=*(S1--);
     
112.                                 }
     
113.                                 *(++S1)=key-(char**)KEY_WORDS+65;
     
114.                                 continue;
     
115.                         }else{
     
116.                                 //无法识别的数学函数
     
117.                                 fputs("Unrecognized math function\n", stderr);
     
118.                                 exit(1);
     
119.                         }
     
120.                         break;
     
121.                
     
122.                 case '(':
     
123.                         *(++S1)=*op;
     
124.                         if(*(op+1)=='-' || *(op+1)=='+'){
     
125.                                 *(S2++)='0', *(S2++)=' ';
     
126.                         }
     
127.                         break;
     
128. 
     
129.                 case ')':
     
130.                         while(*S1!='(')
     
131.                         {
     
132.                                 *(S2++)=*(S1--);
     
133.                         }               
     
134.                         //舍弃'('
     
135.                         S1--;               
     
136.                         break;
     
137. 
     
138.                 case '+':
     
139.                 case '-':
     
140.                         while(S1!=STACK1 && *S1!='(')
     
141.                         {
     
142.                                 *(S2++)=*(S1--);
     
143.                         }
     
144.                         *(++S1)=*op;
     
145.                         break;
     
146. 
     
147.                 case '^':
     
148.                         //指数符
     
149.                         while('A'<=(*S1) && (*S1)<='Z')
     
150.                         {
     
151.                                 *(S2++)=*(S1--);
     
152.                         }
     
153.                         *(++S1)=*op;
     
154.                         break;
     
155. 
     
156.                 case '!':
     
157.                         //阶乘符
     
158.                         *(S2++)=*op;
     
159.                         break;
     
160. 
     
161.                 case '%':
     
162.                 case '*':
     
163.                 case '/':
     
164.                         while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){
     
165.                                 *(S2++)=*(S1--);
     
166.                         }
     
167.                         *(++S1)=*op;
     
168.                         break;
     
169. 
     
170.                 default :
     
171.                         if((*op<'0' || *op>'9') && (*op!='.')){
     
172.                                 //无法识别的运算符
     
173.                                 fputs("Unrecognized operator\n", stderr);
     
174.                                 exit(1);
     
175.                         }
     
176.                         //浮点数入栈
     
177.                         while(('0'<=*op && *op<='9') ||*op=='.'){
     
178.                                 *(S2++)=*(op++);
     
179.                         }
     
180.                         op--;
     
181.                         *(S2++)=' ';
     
182.                         break;
     
183.                 }
     
184.                 op++;
     
185.         }
     
186.         //收尾逆波兰
     
187.         while(S1 !=STACK1){*(S2++)=*(S1--);}
     
188.         *S2=' ';
     
189. 
     
190.         //计算逆波兰
     
191.         op=STACK2;
     
192.         while(*op!=' '){
     
193.                 switch(*op){
     
194.                 case 'A':
     
195.                         *S3=2.7182818284590452;
     
196.                         break;
     
197.                 case 'B':
     
198.                         *S3=3.1415926535897932;
     
199.                         break;
     
200.                 case 'C':
     
201.                         if(*S3 <0){
     
202.                                 //负数没有平方根
     
203.                                 fputs("Negative numbers have no square root\n", stderr);
     
204.                                 exit(1);
     
205.                         }
     
206.                         *(S3-1)=sqrt(*S3);
     
207.                         S3--;
     
208.                         break;
     
209.                 case 'D':
     
210.                         if(*S3 <0){
     
211.                                 //负数没有对数
     
212.                                 fputs("Negative numbers are not logarithmic\n", stderr);
     
213.                                 exit(1);
     
214.                         }
     
215.                         *(S3-1)=log10(*S3);
     
216.                         S3--;
     
217.                         break;
     
218.                 case 'E':
     
219.                         if(*S3 <0){
     
220.                                 //负数没有自然对数
     
221.                                 fputs("Negative numbers have no natural logarithms\n", stderr);
     
222.                                 exit(1);
     
223.                         }
     
224.                         *(S3-1)=log(*S3);
     
225.                         S3--;
     
226.                         break;
     
227.                 case 'F':
     
228.                         *(S3-1)=sin(*S3);
     
229.                         S3--;
     
230.                         break;
     
231.                 case 'G':
     
232.                         *(S3-1)=cos(*S3);
     
233.                         S3--;
     
234.                         break;
     
235.                 case 'H':
     
236.                         if(*S3==3.1415926535897932/2){
     
237.                                 //π/2没有正切值
     
238.                                 fputs("The pi/2 has no tangent\n", stderr);
     
239.                                 exit(1);
     
240.                         }
     
241.                         *(S3-1)=tan(*S3);
     
242.                         S3--;
     
243.                         break;
     
244.                 case 'I':
     
245.                         *(S3-1)=asin(*S3);
     
246.                         S3--;
     
247.                         break;
     
248.                 case 'J':
     
249.                         *(S3-1)=acos(*S3);
     
250.                         S3--;
     
251.                         break;
     
252.                 case 'K':
     
253.                         *(S3-1)=atan(*S3);
     
254.                         S3--;
     
255.                         break;
     
256.                 case 'L':
     
257.                         *(S3-1)=(*S3)*3.1415926535897932/180.0;
     
258.                         S3--;
     
259.                         break;
     
260.                 case 'M':
     
261.                         *(S3-1)=(*S3<0)?(-(*S3)):(*S3);
     
262.                         S3--;
     
263.                         break;
     
264.                 case 'N':
     
265.                         *(S3-1)=round(*S3);
     
266.                         S3--;
     
267.                         break;
     
268.                 case 'O':
     
269.                         *(S3-1)=floor(*S3);
     
270.                         S3--;
     
271.                         break;
     
272.                 case 'P':
     
273.                         *(S3-1)=ceil(*S3);
     
274.                         S3--;
     
275.                         break;
     
276.                 case 'Q':
     
277.                         *(S3-1)=exp(*S3);
     
278.                         S3--;
     
279.                         break;
     
280.                 case 'R':
     
281.                         *(S3-1)=sinh(*S3);
     
282.                         S3--;
     
283.                         break;
     
284.                 case 'S':
     
285.                         *(S3-1)=cosh(*S3);
     
286.                         S3--;
     
287.                         break;
     
288.                 case 'T':
     
289.                         *(S3-1)=tanh(*S3);
     
290.                         S3--;
     
291.                         break;
     
292.                 case 'U':
     
293.                         *(S3-1)=asinh(*S3);
     
294.                         S3--;
     
295.                         break;
     
296.                 case 'V':
     
297.                         *(S3-1)=acosh(*S3);
     
298.                         S3--;
     
299.                         break;
     
300.                 case 'W':
     
301.                         *(S3-1)=atanh(*S3);
     
302.                         S3--;
     
303.                         break;
     
304.                 case '+':
     
305.                         *(S3-1)+=*S3;
     
306.                         S3--;
     
307.                         break;
     
308.                 case '-':
     
309.                         *(S3-1)-=*S3;
     
310.                         S3--;
     
311.                         break;
     
312.                 case '*':
     
313.                         *(S3-1)*=*S3;
     
314.                         S3--;
     
315.                         break;
     
316.                 case '%':
     
317.                 case '/':
     
318.                         if(*S3 !=0){
     
319.                                 if(*op=='%'){
     
320.                                         //取余数
     
321.                                         *(S3-1)=(int)*(S3-1) % (int)*S3;
     
322.                                 }else{
     
323.                                         *(S3-1)/=*S3;
     
324.                                 }
     
325.                                
     
326.                         }else{
     
327.                                 //除数不能为零
     
328.                                 fputs("Divisor is zero error\n", stderr);
     
329.                                 exit(1);
     
330.                         }
     
331.                         S3--;
     
332.                         break;
     
333.                 case '^':
     
334.                         if(*(S3-1)==0 && *S3<0){
     
335.                                 //除数不能为零
     
336.                                 fputs("Function pow's divisor is zero error\n", stderr);
     
337.                                 exit(1);
     
338.                         }
     
339.                         *(S3-1)=pow(*(S3-1), *S3);
     
340.                         S3--;
     
341.                         break;
     
342.                 case '!':
     
343.                         if(*S3 <0){
     
344.                                 //负数没有阶乘
     
345.                                 fputs("Negative numbers have no factorial\n", stderr);
     
346.                                 exit(1);
     
347.                         }
     
348.                         *S3=fact((long long)(*S3));
     
349.                         break;
     
350.                 default :
     
351.                         //字符串转浮点
     
352.                         di=0, ni=1;
     
353.                         while('0'<=*op && *op<='9'){
     
354.                                 di=10*di+(*op)-'0';
     
355.                                 op++;
     
356.                         }       
     
357.                         if(*op=='.'){
     
358.                                 op++;
     
359.                                 while('0'<=*op && *op<='9'){
     
360.                                         di=10*di+(*op)-'0';
     
361.                                         op++, ni*=10;
     
362.                                 }       
     
363.                         }
     
364.                         *(++S3)=di/ni;
     
365.                         break;
     
366.                 }
     
367.                 op++;
     
368.         }
     
369. 
     
370.         /////////////////////////////////////////////////////////////////////
     
371.         //返回计算结果
     
372.         //return *S3;
     
373. 
     
374.         //打印中缀式
     
375.         fprintf(stdout, "ORIGINALEXP: %s\n", expression);
     
376. 
     
377.         //打印后缀式
     
378.         fprintf(stdout, "REVPOLISH:   ");
     
379.         op=STACK2;
     
380.         while(op!=S2){
     
381.                 if(*op=='.' && *(op+1)==' '){
     
382.                         op++;
     
383. 
     
384.                 }else if('A'<=(*op) && (*op)<='Z'){
     
385.                         fprintf(stdout, "%s ", KEY_WORDS[*op-65]);
     
386.                        
     
387.                 }else{
     
388.                         fputc(*op, stdout);
     
389.                         if(*op=='+' ||*op=='-' ||*op=='*' ||*op=='/' ||*op=='%' ||*op=='^' ||*op=='!'){fputc(' ', stdout);}
     
390.                 }
     
391.                 op++;
     
392.         }
     
393.         fputc('\n', stdout);
     
394. 
     
395.         //打印计算结果
     
396.         fprintf(stdout, "RESULT:      %.16lf\n", *S3);
     
397. }
     
398. 
     
399. /*************MAIN主函数入口*************/
     
400. int main(int argc, char** argv)
     
401. {
     
402.         if((argc==1) || (argc==2 && argv[1][0]=='/' && (argv[1][1]=='?'||argv[1][1]=='h'))){
     
403.                 //使用说明
     
404.                 fputs(HELPINFORMATION, stderr);
     
405.                 exit(1);
     
406.         }
     
407.         RevPolishCore(argv[1]);
     
408.         return 0;
     
409. }
     

复制代码

落叶

学了半年就能这水平，只能让我汗颜，我虽然去年才开始学写代码，但之前可是看了十多年计算机方面的书，学的广而泛，
看你的新代码加入了输入值校验功能，看来你也意识到这方面的重要性，我为我的计算器加这个功能可是用了一个多月，
就这样windows的异常处理我还没尝试过，因为关于计算器测试方面的资料没查到。
整个计算器的最终测试用了快两月，才有了一个大致的头绪，里面还没考虑到的问题还多多。
在表达式中支持空格，回车换行，并在解析表达式前除去你也采用了，这点可以增加用户使用体验。

happysxyf

落叶 发表于 2017-1-7 11:41
学了半年就能这水平，只能让我汗颜，我虽然去年才开始学写代码，但之前可是看了十多年计算机方面的书，学的 ...

是的，基本的计算器结构都差不多，都是逆波兰式。你的计算器关键是支持大数和高精度，这点就非常了不起，还有你支持函数定义吗？比如定义 f(x)=sin(x)/x;直接输入f(3.5)求值。

落叶

不支持，高精度这块也没什么要做的，主要定位是用户体验。其实这个计算器最难的是高精度和表达式运算结合在一起。这个计算器最难的是这个框架的建立。
如果只是你所述的函数定义，我考虑了一下，可以快速实现，因为它的核心也是表达式计算，而这个是我计算器的主要功能。

happysxyf

落叶 发表于 2017-1-7 13:47
不支持，高精度这块也没什么要做的，主要定位是用户体验。其实这个计算器最难的是高精度和表达式运算结合在 ...

要是能绘图就更好了

落叶

我的算式存入功能也可实现函数功能，只是不直观，多看看帮助，刚乱码了，我举的例子乱码了。以后增加赋值语句后会有所改观的。

落叶

happysxyf 发表于 2017-1-7 14:04
要是能绘图就更好了

那个绘图就没办法了，那需要团队合作，我既使免强做出一点，也会画虎不成反类猫，个人开发，只能专而精，知识也跟不上。

想请问一下你，你的关键字识别所用方法是你自己所想的吗？比我的方法好多了，我要借荐你的方法。