[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发帖
happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
1楼 跳转到 » 倒序看帖
打印
tT
发表于 2017-1-2 23:15 | 只看该作者

逆波兰计算器 revpolish 3.0版

本帖最后由 happy886rr 于 2017-1-28 15:21 编辑

[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.     REVERSE POLISH EXPRESSION CALCULATOR, COPYRIGHT@2017~2019 BY HAPPYSXYF

  3.     REVPOLISH.EXE

  4.     VERSION 3.0

  5. */

  6. 

  7. #include   <stdio.h>

  8. #include  <stdlib.h>

  9. #include    <math.h>

  10. 

  11. /***************定义宏变量***************/

  12. //堆栈尺寸

  13. #define  STACK_SIZE   1024

  14. //帮助说明

  15. #define HELPINFORMATION "\

  16. REVERSE POLISH EXPRESSION CALCULATOR,COPYRIGHT@2017~2019 BY HAPPY\n\

  17. -----------------------------------------------------------------\n\

  18. revpolish [expression]\n\

  19. -----------------------------------------------------------------\n\

  20. FUNCTIONS:\n\

  21.     pi=3.1415926535897932, e=2.7182818284590452\n\

  22.     +, -, *, /, %, ^, !\n\

  23.     round, floor, ceil, exp, deg, sqrt, abs, lg, ln\n\

  24.     sin, cos, tan, arcsin, arccos, arctan\n\

  25.     sinh, cosh, tanh, arcsinh, arccosh, arctanh\n\

  26. -----------------------------------------------------------------\n\

  27. VERSION 3.0 2017-01-28\n"

  28. 

  29. /***************全局类变量***************/

  30. //数学函数关键词

  31. 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};

  32. //运算符栈

  33. char   STACK1[STACK_SIZE]={0};

  34. //逆波兰栈 

  35. char   STACK2[STACK_SIZE]={0};

  36. //浮点数栈

  37. double STACK3[STACK_SIZE]={0};

  38. 

  39. /***************功能函数类***************/

  40. //阶乘函数

  41. long long fact(long long n)

  42. {

  43.     return (n<2) ?1 :n*(fact(n-1));

  44. }

  45. //逆波兰核心 

  46. double RevPolishCore(const char* expression)

  47. {

  48. 	char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;

  49. 	double *S3=STACK3, di, ni;

  50. 	int    brackets=0;

  51. 	STACK3[0]=0;

  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. 			brackets++;

  124. 			*(++S1)=*op;

  125. 			if(*(op+1)=='-' || *(op+1)=='+'){

  126. 				*(S2++)='0', *(S2++)=' ';

  127. 			}

  128. 			break;

  129. 

  130. 		case ')':

  131. 			brackets--;

  132. 			while(*S1!='(')

  133. 			{

  134. 				*(S2++)=*(S1--);

  135. 			}		

  136. 			//舍弃'(' 

  137. 			S1--;		

  138. 			break;

  139. 

  140. 		case '+':

  141. 		case '-':

  142. 			while(S1!=STACK1 && *S1!='(')

  143. 			{

  144. 				*(S2++)=*(S1--);

  145. 			}

  146. 			*(++S1)=*op;

  147. 			break;

  148. 

  149. 		case '^':

  150. 			//指数符

  151. 			while('A'<=(*S1) && (*S1)<='Z')

  152. 			{

  153. 				*(S2++)=*(S1--);

  154. 			}

  155. 			*(++S1)=*op;

  156. 			break;

  157. 

  158. 		case '!':

  159. 			//阶乘符

  160. 			*(S2++)=*op;

  161. 			break;

  162. 

  163. 		case '%':

  164. 		case '*':

  165. 		case '/':

  166. 			while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){

  167. 				*(S2++)=*(S1--);

  168. 			}

  169. 			*(++S1)=*op;

  170. 			break;

  171. 

  172. 		default :

  173. 			if((*op<'0' || *op>'9') && (*op!='.')){

  174. 				//无法识别的运算符

  175. 				fputs("Unrecognized operator\n", stderr);

  176. 				exit(1);

  177. 			}

  178. 			//浮点数入栈 

  179. 			while(('0'<=*op && *op<='9') ||*op=='.'){

  180. 				*(S2++)=*(op++);

  181. 			}

  182. 			op--;

  183. 			*(S2++)=' ';

  184. 			break;

  185. 		}

  186. 		op++;

  187. 	}

  188. 

  189. 	//验证括号是否闭合

  190. 	if(brackets){

  191. 		fputs("The brackets '(' or ')' are not closed", stderr);

  192. 		exit(1);

  193. 	}

  194. 

  195. 	//收尾逆波兰

  196. 	while(S1 !=STACK1){*(S2++)=*(S1--);}

  197. 	*S2=' ';

  198. 

  199. 	//计算逆波兰

  200. 	op=STACK2;

  201. 	while(*op!=' '){

  202. 		switch(*op){

  203. 		case 'A':

  204. 			*S3=2.7182818284590452;

  205. 			break;

  206. 		case 'B':

  207. 			*S3=3.1415926535897932;

  208. 			break;

  209. 		case 'C':

  210. 			if(*S3 <0){

  211. 				//负数没有平方根

  212. 				fputs("Negative numbers have no square root\n", stderr);

  213. 				exit(1);

  214. 			}

  215. 			*(S3-1)=sqrt(*S3);

  216. 			S3--;

  217. 			break;

  218. 		case 'D':

  219. 			if(*S3 <0){

  220. 				//负数没有对数

  221. 				fputs("Negative numbers are not logarithmic\n", stderr);

  222. 				exit(1);

  223. 			}

  224. 			*(S3-1)=log10(*S3);

  225. 			S3--;

  226. 			break;

  227. 		case 'E':

  228. 			if(*S3 <0){

  229. 				//负数没有自然对数

  230. 				fputs("Negative numbers have no natural logarithms\n", stderr);

  231. 				exit(1);

  232. 			}

  233. 			*(S3-1)=log(*S3);

  234. 			S3--;

  235. 			break;

  236. 		case 'F':

  237. 			*(S3-1)=sin(*S3);

  238. 			S3--;

  239. 			break;

  240. 		case 'G':

  241. 			*(S3-1)=cos(*S3);

  242. 			S3--;

  243. 			break;

  244. 		case 'H':

  245. 			if(*S3==3.1415926535897932/2){

  246. 				//π/2没有正切值

  247. 				fputs("The pi/2 has no tangent\n", stderr);

  248. 				exit(1);

  249. 			}

  250. 			*(S3-1)=tan(*S3);

  251. 			S3--;

  252. 			break;

  253. 		case 'I':

  254. 			*(S3-1)=asin(*S3);

  255. 			S3--;

  256. 			break;

  257. 		case 'J':

  258. 			*(S3-1)=acos(*S3);

  259. 			S3--;

  260. 			break;

  261. 		case 'K':

  262. 			*(S3-1)=atan(*S3);

  263. 			S3--;

  264. 			break;

  265. 		case 'L':

  266. 			*(S3-1)=(*S3)*3.1415926535897932/180.0;

  267. 			S3--;

  268. 			break;

  269. 		case 'M':

  270. 			*(S3-1)=fabs(*S3);

  271. 			S3--;

  272. 			break;

  273. 		case 'N':

  274. 			*(S3-1)=round(*S3);

  275. 			S3--;

  276. 			break;

  277. 		case 'O':

  278. 			*(S3-1)=floor(*S3);

  279. 			S3--;

  280. 			break;

  281. 		case 'P':

  282. 			*(S3-1)=ceil(*S3);

  283. 			S3--;

  284. 			break;

  285. 		case 'Q':

  286. 			*(S3-1)=exp(*S3);

  287. 			S3--;

  288. 			break;

  289. 		case 'R':

  290. 			*(S3-1)=sinh(*S3);

  291. 			S3--;

  292. 			break;

  293. 		case 'S':

  294. 			*(S3-1)=cosh(*S3);

  295. 			S3--;

  296. 			break;

  297. 		case 'T':

  298. 			*(S3-1)=tanh(*S3);

  299. 			S3--;

  300. 			break;

  301. 		case 'U':

  302. 			*(S3-1)=asinh(*S3);

  303. 			S3--;

  304. 			break;

  305. 		case 'V':

  306. 			*(S3-1)=acosh(*S3);

  307. 			S3--;

  308. 			break;

  309. 		case 'W':

  310. 			*(S3-1)=atanh(*S3);

  311. 			S3--;

  312. 			break;

  313. 		case 'X':

  314. 			*(S3-1)=(int)(*S3);

  315. 			S3--;

  316. 			break;

  317. 		case 'Y':

  318. 			if(*S3 <0){

  319. 				//负数没有伽玛函数

  320. 				fputs("Negative numbers have no factorial", stderr);

  321. 				exit(1);

  322. 			}

  323. 			*(S3-1)=tgamma((*S3)+1);

  324. 			S3--;

  325. 			break;

  326. 		case 'Z':

  327. 			//随机数生成器

  328. 			if(*S3 <0){

  329. 				//负数没有伽玛函数

  330. 				fputs("A negative number can not be used as a random upper bound", stderr);

  331. 				exit(1);

  332. 			}else if(*S3 <2){

  333. 				//负数没有伽玛函数

  334. 				*(S3-1)=rand() % 8192 /8192.0;

  335. 			}else{

  336. 				*(S3-1)=rand() % (int)(*S3);

  337. 			}

  338. 			S3--;

  339. 			break;

  340. 		case '+':

  341. 			*(S3-1)+=*S3;

  342. 			S3--;

  343. 			break;

  344. 		case '-':

  345. 			*(S3-1)-=*S3;

  346. 			S3--;

  347. 			break;

  348. 		case '*':

  349. 			*(S3-1)*=*S3;

  350. 			S3--;

  351. 			break;

  352. 		case '%':

  353. 		case '/':

  354. 			if(*S3 !=0){

  355. 				if(*op=='%'){

  356. 					//取余数

  357. 					*(S3-1)=(int)*(S3-1) % (int)*S3;

  358. 				}else{

  359. 					*(S3-1)/=*S3;

  360. 				}

  361. 				

  362. 			}else{

  363. 				//除数不能为零

  364. 				fputs("Divisor is zero error\n", stderr);

  365. 				exit(1);

  366. 			}

  367. 			S3--;

  368. 			break;

  369. 		case '^':

  370. 			if(*(S3-1)==0 && *S3<0){

  371. 				//除数不能为零

  372. 				fputs("Function pow's divisor is zero error\n", stderr);

  373. 				exit(1);

  374. 			}

  375. 			*(S3-1)=pow(*(S3-1), *S3);

  376. 			S3--;

  377. 			break;

  378. 		case '!':

  379. 			if(*S3 <0){

  380. 				//负数没有阶乘

  381. 				fputs("Negative numbers have no factorial\n", stderr);

  382. 				exit(1);

  383. 			}

  384. 			*S3=fact((long long)(*S3));

  385. 			break;

  386. 		default :

  387. 			//字符串转浮点

  388. 			di=0, ni=1;

  389. 			while('0'<=*op && *op<='9'){

  390. 				di=10*di+(*op)-'0';

  391. 				op++;

  392. 			}	

  393. 			if(*op=='.'){

  394. 				op++;

  395. 				while('0'<=*op && *op<='9'){

  396. 					di=10*di+(*op)-'0';

  397. 					op++, ni*=10;

  398. 				}	

  399. 			}

  400. 			*(++S3)=di/ni;

  401. 			break;

  402. 		}

  403. 		op++;

  404. 	}

  405. 

  406. 	//判断结果是否异常或溢出

  407. 	if(isinf(*S3)||isnan(*S3)){

  408. 		fputs("Overflow or illegal operation is calculated", stderr);

  409. 		exit(1);

  410. 	}

  411. 

  412. 	/////////////////////////////////////////////////////////////////////

  413. 	//返回计算结果 

  414. 	//return *S3;

  415. 

  416. 	//打印中缀式

  417. 	fprintf(stdout, "ORIGINALEXP: %s\n", expression);

  418. 

  419. 	//打印后缀式

  420. 	fprintf(stdout, "REVPOLISH:   ");

  421. 	op=STACK2;

  422. 	while(op!=S2){

  423. 		if(*op=='.' && *(op+1)==' '){

  424. 			op++;

  425. 

  426. 		}else if('A'<=(*op) && (*op)<='Z'){

  427. 			fprintf(stdout, "%s ", KEY_WORDS[*op-65]);

  428. 			

  429. 		}else{

  430. 			fputc(*op, stdout);

  431. 			if(*op=='+' ||*op=='-' ||*op=='*' ||*op=='/' ||*op=='%' ||*op=='^' ||*op=='!'){fputc(' ', stdout);}

  432. 		}

  433. 		op++;

  434. 	}

  435. 	fputc('\n', stdout);

  436. 

  437. 	//打印计算结果

  438. 	fprintf(stdout, "RESULT:      %.16lf\n", *S3);

  439. }

  440. 

  441. /*************MAIN主函数入口*************/ 

  442. int main(int argc, char** argv)

  443. {

  444. 	if((argc==1) || (argc==2 && argv[1][0]=='/' && (argv[1][1]=='?'||argv[1][1]=='h'))){

  445. 		//使用说明

  446. 		fputs(HELPINFORMATION, stderr);

  447. 		exit(1);

  448. 	}

  449. 	//初始化随机种子

  450. 	srand((int)getpid());

  451. 	RevPolishCore(argv[1]);

  452. 	return 0;

  453. }
复制代码
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)
复制代码
3

评分人数

    • CrLf: 棒棒哒！PB + 1
    • 523066680: 同支持！PB + 6 技术 + 1
    • 莫奈良: 真的是黑科技 虽然看不懂 还是要支持一下了技术 + 1
收藏 分享

莫奈良

Rank: 1

帖子
37 
积分
94 
技术
4  
捐助
5  
注册时间
2017-1-1 
2楼
发表于 2017-1-6 21:16 | 只看该作者
真的是黑科技 虽然看不懂 还是要支持一下了

TOP

CrLf

Rank: 8Rank: 8

帖子
6388 
积分
18831 
技术
978  
捐助
100  
注册时间
2010-10-9 
3楼
发表于 2017-1-6 23:36 | 只看该作者
名字略怪，还以为是计算逆波兰式的，结果其实是波兰式
链接：在线第三方命令行工具下载   bat、vbs、js 原生混编

TOP

happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
4楼
发表于 2017-1-7 11:14 | 只看该作者
回复 3# CrLf
回复大师，这版主要是优化速度，所以没用数据结构的pop、push，而是用全局静态数组实现的。其中atof也改用自己的实现，所以比调用atof速度要快，核心不调用任何函数，单目、双目全部用双目实现。

TOP

codegay

Rank: 6Rank: 6

帖子
1266 
积分
1775 
技术
162  
捐助
0  
注册时间
2015-12-12 
5楼
发表于 2017-1-7 23:55 | 只看该作者
linux下编译环境的应该是比较好弄。
windows 下有条件和能力的估计不多。
所以exe还是有必要发布一下。
去学去写去用才有进步。安装python3代码存为xx.py 双击运行或右键用IDLE打开按F5运行

TOP

CrLf

Rank: 8Rank: 8

帖子
6388 
积分
18831 
技术
978  
捐助
100  
注册时间
2010-10-9 
6楼
发表于 2017-1-8 00:04 | 只看该作者
回复 5# codegay


    gcc 可以直接编译，但是 gcc 有一个问题，会将带通配符的参数展开为路径，而这个行为是编译器主动进行的，所以我都尽量用 tcc 编译
    无奈的是 tcc 的库太少，编译起来实在不方便
链接：在线第三方命令行工具下载   bat、vbs、js 原生混编

TOP

happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
7楼
发表于 2017-1-8 18:42 | 只看该作者
本帖最后由 happy886rr 于 2017-1-8 18:50 编辑

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

TOP

CrLf

Rank: 8Rank: 8

帖子
6388 
积分
18831 
技术
978  
捐助
100  
注册时间
2010-10-9 
8楼
发表于 2017-1-8 20:29 | 只看该作者
回复 7# happy886rr


    手机有 #include <windows.h> 吗？
链接：在线第三方命令行工具下载   bat、vbs、js 原生混编

TOP

happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
9楼
发表于 2017-1-8 21:44 | 只看该作者
回复 8# CrLf
那个windows头我写多余了，其实只要有stdio和math这两个头就足够。代码无需修改支持各种C平台直接编译。我已经在虚拟机里测试了linux版，完全可用。

TOP

pighead123

Rank: 1

帖子
4 
积分
17 
技术
0  
捐助
0  
注册时间
2011-3-22 
10楼
发表于 2017-2-21 00:51 | 只看该作者
本帖最后由 pighead123 于 2017-2-21 00:56 编辑

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

TOP

返回列表