逆波兰计算器 revpolish 3.0版

/*
    REVERSE POLISH EXPRESSION CALCULATOR, COPYRIGHT@2017~2019 BY HAPPYSXYF
    REVPOLISH.EXE
    VERSION 3.0
*/
 
#include   <stdio.h>
#include  <stdlib.h>
#include    <math.h>
 
/***************定义宏变量***************/
//堆栈尺寸
#define  STACK_SIZE   1024
//帮助说明
#define HELPINFORMATION "\
REVERSE POLISH EXPRESSION CALCULATOR,COPYRIGHT@2017~2019 BY HAPPY\n\
-----------------------------------------------------------------\n\
revpolish [expression]\n\
-----------------------------------------------------------------\n\
FUNCTIONS:\n\
    pi=3.1415926535897932, e=2.7182818284590452\n\
    +, -, *, /, %, ^, !\n\
    round, floor, ceil, exp, deg, sqrt, abs, lg, ln\n\
    sin, cos, tan, arcsin, arccos, arctan\n\
    sinh, cosh, tanh, arcsinh, arccosh, arctanh\n\
-----------------------------------------------------------------\n\
VERSION 3.0 2017-01-28\n"
 
/***************全局类变量***************/
//数学函数关键词
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};
//运算符栈
char   STACK1[STACK_SIZE]={0};
//逆波兰栈 
char   STACK2[STACK_SIZE]={0};
//浮点数栈
double STACK3[STACK_SIZE]={0};
 
/***************功能函数类***************/
//阶乘函数
long long fact(long long n)
{
    return (n<2) ?1 :n*(fact(n-1));
}
//逆波兰核心 
double RevPolishCore(const char* expression)
{
	char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;
	double *S3=STACK3, di, ni;
	int    brackets=0;
	STACK3[0]=0;
	
	//生成逆波兰	
	while(*op!='\0'){		
		switch(*op){
		case ' ' :
		case '\t':
		case '\r':
		case '\n':
			//过滤空字符
			op++;
			continue;
 
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':
			//识别数学函数关键词
			key=(char**)KEY_WORDS;
			while(*key !=NULL){	
				cp=op, kp=*key;
				//比对关键词字母 
				while(*cp==*kp && *kp!='\0'){
					cp++, kp++;
				}
				//验证关键词结尾 
	 			if((*cp<'a'||*cp>'z') && (*kp=='\0')){
	 				op=cp;
					break;
				}
				key++;
			}
			//构建伪双目 
			if(*key !=NULL){				
				*(S2++)='.';
				*(S2++)=' ';
				//伪双目入栈 
				while('A'<=(*S1) && (*S1)<='Z'){
					*(S2++)=*(S1--);
				}
				*(++S1)=key-(char**)KEY_WORDS+65;
				continue;
			}else{
				//无法识别的数学函数
				fputs("Unrecognized math function\n", stderr);
				exit(1);
			}
			break;
		
		case '(':
			brackets++;
			*(++S1)=*op;
			if(*(op+1)=='-' || *(op+1)=='+'){
				*(S2++)='0', *(S2++)=' ';
			}
			break;
 
		case ')':
			brackets--;
			while(*S1!='(')
			{
				*(S2++)=*(S1--);
			}		
			//舍弃'(' 
			S1--;		
			break;
 
		case '+':
		case '-':
			while(S1!=STACK1 && *S1!='(')
			{
				*(S2++)=*(S1--);
			}
			*(++S1)=*op;
			break;
 
		case '^':
			//指数符
			while('A'<=(*S1) && (*S1)<='Z')
			{
				*(S2++)=*(S1--);
			}
			*(++S1)=*op;
			break;
 
		case '!':
			//阶乘符
			*(S2++)=*op;
			break;
 
		case '%':
		case '*':
		case '/':
			while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){
				*(S2++)=*(S1--);
			}
			*(++S1)=*op;
			break;
 
		default :
			if((*op<'0' || *op>'9') && (*op!='.')){
				//无法识别的运算符
				fputs("Unrecognized operator\n", stderr);
				exit(1);
			}
			//浮点数入栈 
			while(('0'<=*op && *op<='9') ||*op=='.'){
				*(S2++)=*(op++);
			}
			op--;
			*(S2++)=' ';
			break;
		}
		op++;
	}
 
	//验证括号是否闭合
	if(brackets){
		fputs("The brackets '(' or ')' are not closed", stderr);
		exit(1);
	}
 
	//收尾逆波兰
	while(S1 !=STACK1){*(S2++)=*(S1--);}
	*S2=' ';
 
	//计算逆波兰
	op=STACK2;
	while(*op!=' '){
		switch(*op){
		case 'A':
			*S3=2.7182818284590452;
			break;
		case 'B':
			*S3=3.1415926535897932;
			break;
		case 'C':
			if(*S3 <0){
				//负数没有平方根
				fputs("Negative numbers have no square root\n", stderr);
				exit(1);
			}
			*(S3-1)=sqrt(*S3);
			S3--;
			break;
		case 'D':
			if(*S3 <0){
				//负数没有对数
				fputs("Negative numbers are not logarithmic\n", stderr);
				exit(1);
			}
			*(S3-1)=log10(*S3);
			S3--;
			break;
		case 'E':
			if(*S3 <0){
				//负数没有自然对数
				fputs("Negative numbers have no natural logarithms\n", stderr);
				exit(1);
			}
			*(S3-1)=log(*S3);
			S3--;
			break;
		case 'F':
			*(S3-1)=sin(*S3);
			S3--;
			break;
		case 'G':
			*(S3-1)=cos(*S3);
			S3--;
			break;
		case 'H':
			if(*S3==3.1415926535897932/2){
				//π/2没有正切值
				fputs("The pi/2 has no tangent\n", stderr);
				exit(1);
			}
			*(S3-1)=tan(*S3);
			S3--;
			break;
		case 'I':
			*(S3-1)=asin(*S3);
			S3--;
			break;
		case 'J':
			*(S3-1)=acos(*S3);
			S3--;
			break;
		case 'K':
			*(S3-1)=atan(*S3);
			S3--;
			break;
		case 'L':
			*(S3-1)=(*S3)*3.1415926535897932/180.0;
			S3--;
			break;
		case 'M':
			*(S3-1)=fabs(*S3);
			S3--;
			break;
		case 'N':
			*(S3-1)=round(*S3);
			S3--;
			break;
		case 'O':
			*(S3-1)=floor(*S3);
			S3--;
			break;
		case 'P':
			*(S3-1)=ceil(*S3);
			S3--;
			break;
		case 'Q':
			*(S3-1)=exp(*S3);
			S3--;
			break;
		case 'R':
			*(S3-1)=sinh(*S3);
			S3--;
			break;
		case 'S':
			*(S3-1)=cosh(*S3);
			S3--;
			break;
		case 'T':
			*(S3-1)=tanh(*S3);
			S3--;
			break;
		case 'U':
			*(S3-1)=asinh(*S3);
			S3--;
			break;
		case 'V':
			*(S3-1)=acosh(*S3);
			S3--;
			break;
		case 'W':
			*(S3-1)=atanh(*S3);
			S3--;
			break;
		case 'X':
			*(S3-1)=(int)(*S3);
			S3--;
			break;
		case 'Y':
			if(*S3 <0){
				//负数没有伽玛函数
				fputs("Negative numbers have no factorial", stderr);
				exit(1);
			}
			*(S3-1)=tgamma((*S3)+1);
			S3--;
			break;
		case 'Z':
			//随机数生成器
			if(*S3 <0){
				//负数没有伽玛函数
				fputs("A negative number can not be used as a random upper bound", stderr);
				exit(1);
			}else if(*S3 <2){
				//负数没有伽玛函数
				*(S3-1)=rand() % 8192 /8192.0;
			}else{
				*(S3-1)=rand() % (int)(*S3);
			}
			S3--;
			break;
		case '+':
			*(S3-1)+=*S3;
			S3--;
			break;
		case '-':
			*(S3-1)-=*S3;
			S3--;
			break;
		case '*':
			*(S3-1)*=*S3;
			S3--;
			break;
		case '%':
		case '/':
			if(*S3 !=0){
				if(*op=='%'){
					//取余数
					*(S3-1)=(int)*(S3-1) % (int)*S3;
				}else{
					*(S3-1)/=*S3;
				}
				
			}else{
				//除数不能为零
				fputs("Divisor is zero error\n", stderr);
				exit(1);
			}
			S3--;
			break;
		case '^':
			if(*(S3-1)==0 && *S3<0){
				//除数不能为零
				fputs("Function pow's divisor is zero error\n", stderr);
				exit(1);
			}
			*(S3-1)=pow(*(S3-1), *S3);
			S3--;
			break;
		case '!':
			if(*S3 <0){
				//负数没有阶乘
				fputs("Negative numbers have no factorial\n", stderr);
				exit(1);
			}
			*S3=fact((long long)(*S3));
			break;
		default :
			//字符串转浮点
			di=0, ni=1;
			while('0'<=*op && *op<='9'){
				di=10*di+(*op)-'0';
				op++;
			}	
			if(*op=='.'){
				op++;
				while('0'<=*op && *op<='9'){
					di=10*di+(*op)-'0';
					op++, ni*=10;
				}	
			}
			*(++S3)=di/ni;
			break;
		}
		op++;
	}
 
	//判断结果是否异常或溢出
	if(isinf(*S3)||isnan(*S3)){
		fputs("Overflow or illegal operation is calculated", stderr);
		exit(1);
	}
 
	/////////////////////////////////////////////////////////////////////
	//返回计算结果 
	//return *S3;
 
	//打印中缀式
	fprintf(stdout, "ORIGINALEXP: %s\n", expression);
 
	//打印后缀式
	fprintf(stdout, "REVPOLISH:   ");
	op=STACK2;
	while(op!=S2){
		if(*op=='.' && *(op+1)==' '){
			op++;
 
		}else if('A'<=(*op) && (*op)<='Z'){
			fprintf(stdout, "%s ", KEY_WORDS[*op-65]);
			
		}else{
			fputc(*op, stdout);
			if(*op=='+' ||*op=='-' ||*op=='*' ||*op=='/' ||*op=='%' ||*op=='^' ||*op=='!'){fputc(' ', stdout);}
		}
		op++;
	}
	fputc('\n', stdout);
 
	//打印计算结果
	fprintf(stdout, "RESULT:      %.16lf\n", *S3);
}
 
/*************MAIN主函数入口*************/ 
int main(int argc, char** argv)
{
	if((argc==1) || (argc==2 && argv[1][0]=='/' && (argv[1][1]=='?'||argv[1][1]=='h'))){
		//使用说明
		fputs(HELPINFORMATION, stderr);
		exit(1);
	}
	//初始化随机种子
	srand((int)getpid());
	RevPolishCore(argv[1]);
	return 0;
}COPY

gcc revpolish.c -std=gnu99 -O3 -s -o revpolish.exeCOPY

@echo off
::****************************************************
:HEAD
revpolish
ping -n 2 127.1>NUL
echo;
echo;
 
::****************************************************
:TEST
for /f "delims=" %%a in ('more +16 "%~f0"') do (
	revpolish "%%a"&echo;
)
set/p=Well Done!&exit
 
::****************************************************
abs(1/(2*50)*lg(2*pi*(e^2)/(2*50+1))-lg2)
((((((((2^2)*2)^2)*2)^2)*2)^2)^2)*2
-((((((((2^2)*2)^2)*2)^2)*2)^2)^2)*2
23+56/(102-100)*((36-24)/(8-6))
sin(6)+3
cos(sin(6)^4)^6
cos(sin(-6)^4)^6
cos(-sin(6)^4)^6
2^cos(sin(6)^4)^6
2^sin(3)^2
4^4!
3^4^2
gamma(20.3)COPY