mathstring.cpp

该类有以下特点： 1.支持字符串中含有各种常用函数

			if(seekStr(string,i,"pow"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=14;
				i--;                     
				continue;  
			}
		}//if(string[i]=='p')
		//string[i]为以s开头的库函数
		if(string[i]=='s')
		{
			if('0'<=string[i-1] && string[i-1]<='9')  //该函数前为数字
			{              //在该函数入栈stact前加一次对'*'的处理
				while(stack[top].oper=='*' || stack[top].oper=='/'||
				stack[top].flag==2)
				{
				   bolan[j]=stack[top];
				   j++;
				   top--;
				}
			    //将'*'压入栈stact中
		    	top++;
			    stack[top].flag=1;
			    stack[top].oper='*';
			}
			//为sin(x)函数
			if(seekStr(string,i,"sin"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=15;
				i--;                     
				continue;  
			}
			//为sinh(x)函数
			if(seekStr(string,i,"sinh"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=16;
				i--;                     
				continue;  
			}
			//为sin(x)函数
			if(seekStr(string,i,"sqrt"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=17;
				i--;                     
				continue;  
			}
		}//if(string[i]=='s')
		//string[i]为以t开头的库函数
		if(string[i]=='t')
		{
			if('0'<=string[i-1] && string[i-1]<='9')  //该函数前为数字
			{              //在该函数入栈stact前加一次对'*'的处理
				while(stack[top].oper=='*' || stack[top].oper=='/'||
				stack[top].flag==2)
				{
				   bolan[j]=stack[top];
				   j++;
				   top--;
				}
			    //将'*'压入栈stact中
		    	top++;
			    stack[top].flag=1;
			    stack[top].oper='*';
			}
			//为tan(x)函数
			if(seekStr(string,i,"tan"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=18;
				i--;                     
				continue;  
			}
			//为tanh(x)函数
			if(seekStr(string,i,"tanh"))   
			{                            //将该函数入栈stact中
				top++;
				stack[top].flag=2;
				stack[top].func=19;
				i--;                     
				continue;  
			}
		}//if(string[i]=='p')
	    
		//判定string[i]=',',将栈stact中'('后的运算符和函数全部弹出，
		//压入数组bolan中，
		if(string[i]==',')
		{
			while(stack[top].oper!='(')
			{
				bolan[j]=stack[top];
				j++;
				top--;
			}
			continue;
		}

		//判定string[i]='x',则用类中未知数变量xx代替，压入数组bolan中 
		if(string[i]=='x')
		{
			bolan[j].flag=0;   //标识为数值
			bolan[j].value=xx;
			j++;
		}
    }

	//转换结束时，若栈stact不为空，则将栈内所有运算符和函数弹出，存入
	//数组bolan中
	while(top!=0)
	{
		bolan[j]=stack[top];
		j++;
		top--;
	}

	//转换结束，在数组bolan尾加一opera='#'作为结束符
    bolan[j].oper='#';

    return 1;
}

//将数字字符串转化成数值
double CMathString::stringToDigital(char *s)
{
	double sum=0,    //转化后的数值
		temp,
		ten=0.1;     //小数变化值
	int i,ch,
		flag=0;    //标识是小数还是整数，0为整数
	for(i=0;s[i]!='\0';i++)
	{
		if(s[i]!='.')
		{
			if(flag==0)  //整数部分
			{
				ch=s[i]-'0';
				sum=sum+ch;
				sum=sum*10;
			}
			else        //小数部分
			{
				ch=s[i]-'0';
				temp=ch*ten;   //小数点移位
				sum=sum+temp;
				ten=ten*0.1;    //改变小数点位置
			}
		}
		else     //小数点
		{
			sum=sum/10;
			flag=1;
		}
	}//for
	if(flag==0)    //无小数部分
		sum=sum/10;
	return sum;

}

//求波兰式bolan的值
//方法如下：
//1.若节点bolan[i]为数值，则如数据栈dataStact
//2.若节点bolan[i]为运算符，则从数据栈dataStact弹出数据进行计算，并
//  将结果压入数据栈dataStact中
//3.若节点bolan[i]为函数，则从数据栈dataStact弹出数据，调用相应的库
//  函数进行计算，并将结果压入数据栈dataStact中
//4.若节点bolan[i]为结束符'#',则数据栈dataStact中的数据弹出，赋给
//  result，并返回0
//返回值:
//1. 计算正确，返回0
//2. 在计算中若除数为0，返回1
//3. 反余弦函数acos(x)中的x不满足条件，返回2
//4. 反正弦函数asin(x)中的x不满足条件，返回3
//5. 余切函数cot(x) 中tan（x）为0，返回4
//6.取模x%y函数mod(x,y)中y为0，返回5
//7.自然对数函数ln(x),如果x<=0,则返回6
//8.取10的对数函数log10(x),如果x<=0,则返回7
//9.开方函数sqrt(x),如果x<0,则返回8
//10.计算中有其他错误，返回-1
int CMathString::compvalue(void)
{
	double  dataStack[MAX/2];   //存放中间数据的数据栈
	int top=0,            //数据栈dataStact的栈顶
		i;              //数组bolan的下标
	for(i=0;bolan[i].oper!='#';i++)
	{
		//节点bolan[i]为数值，则如数据栈dataStact
		if(bolan[i].flag==0)
		{
			top++;
			dataStack[top]=bolan[i].value;
			continue;
		}

		//节点bolan[i]为运算符，则从数据栈dataStact弹出数据进行计算，并
        //将结果压入数据栈dataStact中
		//在计算中若除数为0，返回1
		if(bolan[i].flag==1)
		{
			switch(bolan[i].oper)
			{
			case '+':
				dataStack[top-1]=dataStack[top-1]+dataStack[top];
				top--;
				break;
				
			case  '-':
				dataStack[top-1]=dataStack[top-1]-dataStack[top];
				top--;
				break;

			case '*':
                dataStack[top-1]=dataStack[top-1]*dataStack[top];
				top--;
				break;

			case '/':
				if(dataStack[top]!=0.0)
				{
					dataStack[top-1]=dataStack[top-1]/dataStack[top];
				    top--;
				    break;
				}
				else  //除数为0，返回1
				{
					return 1;
				}
			case '~':      //取负
				dataStack[top]=0-dataStack[top];
				break;
			}//switch
			continue;
		}//if(bolan[i].flag==1)

		//若节点bolan[i]为函数，则从数据栈dataStact弹出数据，调用相应
		//的库函数进行计算，并将结果压入数据栈dataStact中
		if(bolan[i].flag==2)
		{
			switch(bolan[i].func)
			{
			case 1:    //求绝对值函数abs(x)
				dataStack[top]=fabs(dataStack[top]);
				break;

			case 2:    //反余弦函数acos(x)
				if(-1.0<=dataStack[top] && dataStack[top]<=1.0)
				{
				    dataStack[top]=acos(dataStack[top]);
				    break;
				}
				else  //反余弦函数acos(x)中的x不满足条件，返回2
				{
					return 2;
				}

			case 3:   //反正弦函数asin(x)
				if(-1<=dataStack[top] && dataStack[top]<=1)
				{
				    dataStack[top]=asin(dataStack[top]);
				    break;
				}
				else  //反正弦函数asin(x)中的x不满足条件，返回3
				{
					return 3;
				}

			case 4:   //反正切函数atan(x)
				dataStack[top]=atan(dataStack[top]);
				break;

			case 5:  //反余切函数acot(x)
				dataStack[top]=PI/2-atan(dataStack[top]);
				break;

			case 6:   //余弦函数cos(x)
				dataStack[top]=cos(dataStack[top]);
				break;
               
			case 7:    //双曲余弦cosh(x)
				dataStack[top]=cosh(dataStack[top]);
				break;

			case 8:    //余切函数cot(x)   cot(x)=1/tan(x)
				if(tan(dataStack[top])!=0)
				{
					dataStack[top]=1/tan(dataStack[top]);
					break;
				}
				else    //余切函数cot(x) 中tan（x）为0，返回4
				{
					return 4;
				}
				
			case 9:    //e的x次方函数exp(x)
				dataStack[top]=exp(dataStack[top]);
				break;

			case 10:   //求不大于x的最大整数 floor(x)
				dataStack[top]=floor(dataStack[top]);
				break;

			case 11:   //取模x%y函数mod(x,y),即
				if(dataStack[top]!=0)
				{
				   dataStack[top-1]=fmod(dataStack[top-1],dataStack[top]);
				   top--;
				   break;
				}
				else   //取模x%y函数mod(x,y)中y为0，返回5
				{
					return 5;
				}

			case 12:    //自然对数函数ln(x),如果x<=0,则返回6
				if(dataStack[top]>0)
				{          //ln(x)的库函数为log(x)
					dataStack[top]=log(dataStack[top]);
					break;
				}
				else
				{
					return 6;
				}

			case 13:    //取10的对数函数log10(x),如果x<=0,则返回7
				if(dataStack[top]>0)
				{          //log10(x)的库函数为log10(x)
					dataStack[top]=log10(dataStack[top]);
					break;
				}
				else
				{
					return 7;
				}

			case 14:    //x的y次方函数pow(x,y)
				dataStack[top-1]=pow(dataStack[top-1],dataStack[top]);
				top--;
				break;

			case 15:    //正弦函数sin(x)
				dataStack[top]=sin(dataStack[top]);
				break;

			case 16:    //双曲正弦sinh(x)
				dataStack[top]=sinh(dataStack[top]);
				break;

			case 17:   //开方函数sqrt(x),如果x<0,则返回8
				if(dataStack[top]>=0)
				{
					dataStack[top]=sqrt(dataStack[top]);
					break;
				}
				else
				{
					return 8;
				}

			case 18:    //正切函数tan(x)
				dataStack[top]=tan(dataStack[top]);
				break;

			case 19:    //双曲正切函数tanh(x)
				dataStack[top]=tanh(dataStack[top]);
				break;
            }//switch(bolan[i].func)
			continue;
		}//if(bolan[i].flag==2)
	}//for(i=0;bolan[i].oper!='#';i++)
	if(top==1)       //计算正确
	{
		result=dataStack[top];
		return 0;    //返回0
	}
	else           //计算中有其他错误，返回-1
		return -1;   
}

double CMathString::getvalue(void)  //返回计算得到的表达式值
{
	return result;
}