caltype.c

即时计算加法

/*
  Name:CalType.c
  Copyright:
  Author: 
  Date: 21-11-08 13:48
  Description:数学函数
*/

#include "includes.h"

extern Liner * CalLine_;
extern Lstack * CalStack_;
extern int ResFlag;
extern SET setREC [NUM_SET];//在这里引入这一数组是为了判断角度制
FTYPE FUNList [ FUN_NUM ];//读入的运算符列表

/*
  Function Name:calproc 
  Author: 
  Description:对指定的运算符代码进行计算,并返回计算结果 
*/

num calproc ( int calft ,Lstack * CalStack )
{	
	//calpro函数中必须将计算结果进栈并置numflag=1(须判断negflag),不包含当前元素退栈
	num x,y;//记录在栈非空情况下取到的待运算的数字(最多两个)
	num proResult;//用于临时存储计算结果
	switch(calft/10%10)      //十位数表示运算符目数
	{
		case 0:		//常数
			{
		
				switch(calft)
				{
				case pi__:
					{
							proResult = pi___();
							break;	
					}
				case e__:
					{
							proResult = e___();
							break;	
					}
				}
                break;
			}
		case 1:		//单目运算	(注意:十位数为1或3时均表示单目运算)
		case 3:
			{
				if(CalStack->Dtop-CalStack->Dstack==CalStack->StackLen)   
					Error(E_GE);			//若栈空,语法错误			
				else 
				     {	
                        x=*(--CalStack->Dtop);
                     }

				switch(calft)
				{
					case sin__:
						{
							proResult=sin_(x); 								  
							break;						
						}
					case cos__:
						{
							proResult=cos_(x);					  
							break;						
						}
					case tan__:
						{
							proResult=tan_(x);
							break;						
						}
					case cot__:
						{
							proResult=cot_(x);							 						  
							break;						
						}
					case sec__:
						{
							proResult=sec_(x);		
							break;						
						}
					case csc__:
						{
							proResult=csc_(x);
							break;						
						}
					case arcsin__:
						{
							proResult=arcsin_(x);
							break;						
						}
					case arccos__:
						{
							proResult=arccos_(x);
							break;									
						}
					case arctan__:
						{
							proResult=arctan_(x);
							break;						
						}
					case ln__:
						{
							proResult=ln_(x);
							break;						
						}
					case lg__:
						{
							proResult=lg_(x);
							break;						
						}
					case sinh__:
						{
							proResult=sinh_(x);
							break;						
						}
					case cosh__:
						{
							proResult=cosh_(x);
							break;						
						}
					case tanh__:
						{
							proResult=tanh_(x);
							break;						
						}
					case neg__:
						{
							proResult=neg_(x);
							break;
						}
					case sqrt__:
                        {
                            proResult=sqrt_(x);   
                            break; 
                        }
                    case n__:
                        {
                            proResult=n_(x);
                            break; 
                        }  
                              
				}//switch
				break;
			}//case 1:
		case 2:     //双目运算
			{
                if(CalStack->Dtop-CalStack->Dstack==CalStack->StackLen)  		
					Error(E_GE);			//若栈空,语法错误			
				else 
					x=*(--CalStack->Dtop);
                if(CalStack->Dtop-CalStack->Dstack==CalStack->StackLen)  		
					Error(E_GE);			//若栈空,语法错误			
				else 
					y=*(--CalStack->Dtop);

				switch(calft)
				{
					case  plus:
						{
							proResult=plus_(x,y);
							break;
						}
					case minus:
						{													
							proResult=minus_(y,x);  //必须是先进栈的数减去后进栈的数 
							break;					
						}
					case multi:
						 {
							proResult=multi_(x,y);
							break;
						 }
					case divide:                   
						 {
							proResult=divide_(y,x);  //必须是先进栈的数除以后进栈的数
							break;
						 }
					case ntime__:
						 {
							proResult=ntime_(y,x);  //必须是先进栈的数^后进栈的数
							break;
						 }
					case c__:
						 {
							proResult=c___(y,x);  //先进栈的数为底 
							break;
						 }
					case p__:
						 {
							proResult=p___(y,x);  //先进栈的数为底 
							break;
						 }
		            case nroot__:
                         {
							proResult=nroot_(y,x);  //先进栈的数开y次方 
							break;  
                         }                              
				}//switch
				break;
			}//case 2:
	}//switch
	return(proResult);
}

/*
  Function Name:ftype
  Author: 
  Description:用于转换运算符内码
*/

ftype funtype ( char * CalFUN )
{
	int i;//临时变量
	for ( i = 0 ; i < FUN_NUM ; ++i )
	{
		if ( strcmp( CalFUN , FUNList [i].Ftype ) == 0 )
		{
			return FUNList [i].Fnum ;//返回运算符内码
		}
	}
	return -1 ;//特殊的运算符，表示该运算符非法，返回此运算符的时候，应调用E_GE错误例程
}

/*
  Function Name:LoadFUN
  Author: 
  Description:读入运算符列表
*/

void LoadFUN ( void )
{
	FILE * funset = NULL ;//声明文件指针
	int i;//临时变量
	funset = fopen ( "OPER.BIN" , "rb" );//打开文件
	if ( funset == NULL )
	{
		Error ( E_FAIL_LOAD_SET );//未打开时的错误处理
	}
	else
	{
		for ( i = 0 ; i < FUN_NUM ; ++i )
		{
			fread( &(FUNList[i]) , sizeof ( FTYPE ) , 1 , funset );//读入文件内容
		}
	}
	/*
	for(i=0;i<23;i++)
	puts(FUNList[i].Ftype);
	getch();
	*/
}

/*
  Function Name:plus_
  Author: 
  Description:加法
*/

num plus_ ( num num1 , num num2 )
{
	return ( num1 + num2 );
}

/*
  Function Name:minus_
  Author: 
  Description:减法
*/

num minus_ ( num num1 , num num2 )
{
	return ( num1 - num2 );
}

/*
  Function Name:neg_
  Author: 
  Description:求相反数 
*/

num neg_ ( num num1 )
{
    return ( -num1 );
}

/*
  Function Name:multi_
  Author: 
  Description:乘法
*/

num multi_ ( num num1 , num num2 )
{
	return ( num1 * num2 );
}

/*
  Function Name:divide_
  Author: 
  Description:除法
*/

num divide_ ( num num1 , num num2 )
{
	if ( num2 == 0 )
	{
		Error ( E_GE );
	}
	else
	{
		return ( num1 / num2 );
	}
}

/*
  Function Name:sin_
  Author: 
  Description:正弦函数
*/

num sin_ ( num num1 )//正弦
{
	if ( setREC [1] == DEG )
	{
		return sin( num1 * PI / 180 );
	}
	else
	{
		return sin( num1 );
	}
}

/*
  Function Name:cos_
  Author: 
  Description:余弦函数
*/
num cos_ ( num num1 )
{
	if ( setREC [1] == DEG )
	{
		return cos ( num1 * PI / 180 );
	}
	else
	{
		return cos ( num1 );
	}
}

/*
  Function Name:tan_
  Author: 
  Description:正切函数
*/

num tan_ ( num num1 )
{
	if ( setREC [1] == DEG )
	{
          return tan ( num1 * PI / 180 );
	}
	else
	{
		     return tan ( num1 );
	}
}

/*
  Function Name:cot_
  Author: 
  Description:余切函数
*/

num cot_ ( num num1 )
{
    return (divide_(1,tan_(num1))); //modified by  
}

/*
  Function Name:sec_
  Author: 
  Description:正割函数
*/

num sec_ ( num num1 )
{
	if ( setREC [1] == DEG )
	{
		return 1.0 / ( cos ( num1 * PI / 180 ));
	}
	else
	{
		return 1.0 / ( cos ( num1 ));
	}
}

/*
  Function Name:csc_
  Author: 
  Description:余割
*/

num csc_ ( num num1 )
{
	if ( setREC [1] == DEG )
	{
		return 1.0 / ( sin ( num1 * PI / 180 ));
	}
	else
	{
		return 1.0 / ( sin ( num1 ));
	}
}

/*
  Function Name:arcsin_ 
  Author: 
  Description:反正弦 
*/

num arcsin_ ( num num1 )
{
    if(num1>1||num1<-1)
           Error ( E_GE );
	else
        if ( setREC [1] == DEG )
    	{
    		return ( asin ( num1  )* 180 / PI);
    	}
    	else
    	{
    		return ( asin ( num1 ));
    	}
}

/*
  Function Name:arccos_ 
  Author: 
  Description:反余弦 
*/

num arccos_ ( num num1 )
{
    if(num1>1||num1<-1)
           Error ( E_GE );
	else
        if ( setREC [1] == DEG )
    	{
    		return ( acos ( num1  )* 180 / PI);
    	}
    	else
    	{
    		return ( acos ( num1 ));
    	}
}

/*
  Function Name:arctan_ 
  Author: 
  Description:反正切 
*/

num arctan_ ( num num1 )
{
        if ( setREC [1] == DEG )
    	{
    		return ( atan ( num1  )* 180 / PI);
    	}
    	else
    	{
    		return ( atan ( num1 ));
    	}
}

/*
  Function Name:ln_ 
  Author: 
  Description:自然对数 
*/

num ln_ ( num num1 )
{
	if ( num1 <= 0 )
	{
		Error ( E_GE );
	}
	else
	{
		return log( num1 );
	}
}

/*
  Function Name:lg_ 
  Author: 
  Description:常用对数 log10 
*/

num lg_ ( num num1 )
{
	if ( num1 <= 0 )
	{
		Error ( E_GE );
	}
	else
	{
		return log10( num1 );
	}
}

/*
  Function Name:sinh_ 
  Author: 
  Description:双曲正弦 
*/

num sinh_ ( num num1 )
{
		return sinh( num1 );
}

/*
  Function Name:cosh_ 
  Author: 
  Description:双曲余弦
*/

num cosh_ ( num num1 )
{
		return cosh( num1 );
}

/*
  Function Name:tanh_ 
  Author: 
  Description:双曲正切
*/ 

num tanh_ ( num num1 )
{
		return tanh( num1 );
}

/*
  Function Name:sqrt_ 
  Author: 
  Description:开二次方
*/ 

num sqrt_ ( num num1 )
{
	if ( num1 < 0 )
	{
		Error ( E_GE );
	}
	else
	{
		return sqrt( num1 );
	}
}

/*
  Function Name:n_
  Author: 
  Description:阶乘
*/
int n_ ( num num1 )
{
	int Tnum1 , i , s = 1;
	Tnum1 = ( int ) num1;
	if ( Tnum1 < 0 )
	{
		Error ( E_GE );
		return 0;
	}
	for ( i = 1 ; i<= Tnum1 ; ++i )
	{
		s *= i;
	}
	return s;
}

/*
  Function Name:ntime_ 
  Author: 
  Description:幂
*/

num ntime_ ( num num1,num num2 )
{
    num temp;
    temp=pow(num1,num2);
   // if(temp<(- 1.79769e+308 )||temp>( 1.79769e+308 )) //数据溢出,说明出现了运算数不合法的情况 比如,(-2)^(2.25) 
         	//Error ( E_GE );
   	//else 
       return temp;
}

/*
  Function Name:c_
  Author: 
  Description:组合
*/
int c___ ( num num1 , num num2 )
{
	int Tnum1 , Tnum2;//临时变量
	Tnum1 = ( int ) num1;
	Tnum2 = ( int ) num2;
	if ( Tnum1 < 0 || Tnum2 < 0 || Tnum1 < Tnum2 )
	{
		Error ( E_GE );
		free ( CalLine_ );
		free ( CalStack_ );
		return 0;
	}
    return( p___( Tnum1 , Tnum2 )/n_( Tnum2 ));//return ( n_ ( Tnum1 ) / n_ ( Tnum1 ) / n_ ( Tnum1 - Tnum2 )); //modified by 
}

/*
  Function Name:p_
  Author: 
  Description:排列
*/
int p___ ( num num1 , num num2 )
{
	int Tnum1 , Tnum2;//临时变量
	Tnum1 = ( int ) num1;
	Tnum2 = ( int ) num2;
	if ( Tnum1 < 0 || Tnum2 < 0 || Tnum1 < Tnum2 )
	{
		Error ( E_GE );
		free ( CalLine_ );
		free ( CalStack_ );
		return 0;
	}
	else
	{
		return ( n_ ( Tnum1 ) / n_ ( Tnum1 - Tnum2 ));
	}
}

/*
  Function Name:nroot_ 
  Author: 
  Description:开x次方,第一个参数为被开x次方数
*/

num nroot_ ( num num1,num num2 )
{
		return ntime_(num2,divide_(1,num1));
}

/*
  Function Name:pi_
  Author: 
  Description:圆周率
*/
num pi___ ( void )
{
	return PI ;
}

/*
  Function Name:e___
  Author: 
  Description:自然底
*/

num e___ ( void )
{
	return E ;
}