逆波兰计算器 revpolish 3.0版

happy886rr

[version 3.0]  2017-01-28，更新只更新源码，而不做下载更新，请编译源码获取最新版。
逆波兰计算器revpolish 3.0版，支持复杂多函数混合嵌套。恐怖的计算速度，四则运算每秒可以处理1000万行，复杂数学函数嵌套，每秒可处理200万行。支持最全面的数学函数，支持超长算式，可以自定义#define  STACK_SIZE 的值，理论上不限制算式长度。拥有详细的错误反馈，无论是除数为0，还是负数开方，都会立刻终止程序并打印错误信息。跳转排序亦根据使用频率设定，使其以最小的内存、cpu占用、最快的速度完成艰巨的科学计算。

revpolish采取多版本发行策略，请下载支持您设备的版本。

摘要：
x86&x64架构windows版， 下载：revpolish.exe


x86&x64架构linux版， 下载： revpolish


安卓apk 版， 下载： revpolish.apk


arm架构版， 下载： revpolish

用法：
-----------------------------------------------------------------------------
revpolish [expression]
-----------------------------------------------------------------------------

示例:
-----------------------------------------------------------------------------
    revpolish ((3*3+2)%6+7.187)*5-7/189+3^2
    revpolish (ceil(sin(pi/3)+2)%6+0.187)*e-lg(6.5)
    revpolish 5*(arctan(cos(sin(ln(lg(2.71828))))))
-----------------------------------------------------------------------------

备注：
-----------------------------------------------------------------------------
常数类
        pi    3.1415926535897932
        e     2.7182818284590452
通用类
        rand  随机数
        round 四舍五入
        int   取整
        ceil  向上舍入
        floor 向下舍入
        abs   绝对值
        sqrt  开方
        lg    常用对数，以10为底
        ln    自然对数
        exp   e的次幂
        gamma 伽玛函数
        deg   度转弧度
        +     加
        -     减
        *     乘
        /     除
        %     取余数
        ^     次方
        !     阶乘
三角函数类
        sin、cos、tan   
        arcsin、arccos、arctan
双曲函数类
        sinh、cosh、tanh
        arcsinh、arccosh、arctanh
-----------------------------------------------------------------------------

revpolish.c   3.0版本源码

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

复制代码

gcc编译参数

1. gcc revpolish.c -std=gnu99 -O3 -s -o revpolish.exe

复制代码

cmd调用示例

1. @echo off
   
2. ::****************************************************
   
3. :HEAD
   
4. revpolish
   
5. ping -n 2 127.1>NUL
   
6. echo;
   
7. echo;
   
8. 
   
9. ::****************************************************
   
10. :TEST
    
11. for /f "delims=" %%a in ('more +16 "%~f0"') do (
    
12.         revpolish "%%a"&echo;
    
13. )
    
14. set/p=Well Done!&exit
    
15. 
    
16. ::****************************************************
    
17. abs(1/(2*50)*lg(2*pi*(e^2)/(2*50+1))-lg2)
    
18. ((((((((2^2)*2)^2)*2)^2)*2)^2)^2)*2
    
19. -((((((((2^2)*2)^2)*2)^2)*2)^2)^2)*2
    
20. 23+56/(102-100)*((36-24)/(8-6))
    
21. sin(6)+3
    
22. cos(sin(6)^4)^6
    
23. cos(sin(-6)^4)^6
    
24. cos(-sin(6)^4)^6
    
25. 2^cos(sin(6)^4)^6
    
26. 2^sin(3)^2
    
27. 4^4!
    
28. 3^4^2
    
29. gamma(20.3)
    

复制代码

莫奈良

真的是黑科技 虽然看不懂 还是要支持一下了

CrLf

名字略怪，还以为是计算逆波兰式的，结果其实是波兰式

happy886rr

回复 3# CrLf
回复大师，这版主要是优化速度，所以没用数据结构的pop、push，而是用全局静态数组实现的。其中atof也改用自己的实现，所以比调用atof速度要快，核心不调用任何函数，单目、双目全部用双目实现。

codegay

linux下编译环境的应该是比较好弄。
windows 下有条件和能力的估计不多。
所以exe还是有必要发布一下。

CrLf

回复 5# codegay


    gcc 可以直接编译，但是 gcc 有一个问题，会将带通配符的参数展开为路径，而这个行为是编译器主动进行的，所以我都尽量用 tcc 编译
    无奈的是 tcc 的库太少，编译起来实在不方便

happy886rr

回复 6# CrLf
大师手机上也能编译，我用c4droid的手机版tcc直接.编译成了apk和arm架构C版本,已更新到顶楼。在手机上的体验很棒，完全取代了自带的计算器，有12位有效精度。

CrLf

回复 7# happy886rr


    手机有 #include <windows.h> 吗？

happy886rr

回复 8# CrLf
那个windows头我写多余了，其实只要有stdio和math这两个头就足够。代码无需修改支持各种C平台直接编译。我已经在虚拟机里测试了linux版，完全可用。

pighead123

很好，怎么不放到 github 去？放上去就方便管理和发布了