automata.cpp

Windows CE上的计算器

            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kTangent:
            /*************************************************
             * tangent (n+1/2)pi ==> infinate >_<            *
             *************************************************/
            if(type==DEG){value=value/180*M_PI;}
            else
                if(type==GRD){value=value/200*M_PI;}
            if (fabs(fmod(fabs(value/M_PI), 1)-0.5)<1E-10) {
                this->error();
            }
            value=tan( value );\
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
            
        case kArcTangent:
            value=atan( value );
            
            if(type==DEG)
                value=value*180/M_PI;
            else if(type==GRD)
                value=value*200/M_PI;
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kLog10:
            if(value<=0.0){
                this->error();
                mState=_STATE_ERR_;
            }
            value=log10(value);
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kLn:
            if(value<=0.0){
                this->error();
                mState=_STATE_ERR_;
            }
            value=log(value);
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kSquare:
            value*= value ;
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kCube:
            value= value*value*value ;
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kClearCurrent:
            mDisplay=_K_ZERO_;
            mState=_STATE_O_;
            break;
        case kConstantPI:
            mDisplay=_K_PI;
            mState=_STATE_C_;
            break;
        case kConstantE:
            mDisplay=_K_E;
            mState=_STATE_C_;
            break;
        case kToInteger:
            value= floor(value) ;
            //value=stringToDouble(mDisplay);
            
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
/*********************************************************/ 
        case kReset:
            this->reset();
        case kBackSpace:
            switch (mState) {
                case _STATE_A_:
                case _STATE_B_:
                    tmp_len=mDisplay.size()-1;
                    if (mDisplay.at(tmp_len)=='.') {
                        mState=_STATE_A_;
                    }
                    mDisplay.deletelast();
                    if (tmp_len==0
                    || 0==mDisplay.compare("-")
                    || 0==mDisplay.compare("-0")
                    || 0==mDisplay.compare("0")) {
                        mDisplay=_K_ZERO_;
                        mState=_STATE_O_;
                    }
                    break;
                default:break;
            }
            break;
/************************************************************************/
        case kMemoryAdd:
            memory.Add(value);mState=_STATE_C_;return ST_UPDATE_MEMORY;break;
        case kMemoryClear:
            memory.Clear();mState=_STATE_C_;return ST_UPDATE_MEMORY;break;
        case kMemoryRead:
            value=memory.Read();
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kMemorySave:
            memory.Save(value);mState=_STATE_C_;return ST_UPDATE_MEMORY;break;
    }
    return ST_UPDATE_DISPLAY;
}

bool CAutoMata::hasMemoryStored(){
    return memory.isStored();
}
//************************************
// FullName:  CAutoMata::getDisplay
// Access:    public 
// Returns:   mystring
// 返回计算结果
// 出错则返回"ERROR"
//************************************
mystring CAutoMata::getDisplay(){
    static char *error="Error";
    if (this->err) {
        this->mDisplay.clear();
        this->mDisplay.append(error);
        return mDisplay;
    }
    int len=mDisplay.size();
    if(len==0 || len==1
    || mState==_STATE_B_
    || mState==_STATE_A_
    || mState==_STATE_O_)
        return mDisplay;
    return mDisplay;
}
/************************************************************************
 *              遇到运算符(+,-,*,/,MOD,^)更新栈                         *
 *				遇到除0则出错，停止计算									*			
 ************************************************************************/
void CAutoMata::updateStack(int op){
    int op_level(int op);	
    int level=op_level(op);   //当前操作符优先级
    double top=mDisplay.toDouble();
    this->mStackOperand.push(top);
	//判断优先级和栈顶优先级的大小
    while(!mStackOperator.empty()	//直到操作符栈空
		&&(level<=op_level(this->mStackOperator.top()))){		//并且保证栈顶优先级最高
                int top_op=mStackOperator.top();	//std::stack::pop()函数没有返回值
				mStackOperator.pop();				//所以调用两个函数来实现这一功能
                
                long double s2=mStackOperand.top();
                mStackOperand.pop();
                
                long double s1= mStackOperand.top();
                mStackOperand.pop();
                //判断是那种运算，并将计算结果压到操作数栈顶
                switch(top_op){
                    case kAdd		:mStackOperand.push(s1+s2);break;	//加法
                    case kMinus		:mStackOperand.push(s1-s2);break;	//减法
                    case kMuliply	:mStackOperand.push(s1*s2);break;	//乘法
                    case kDivide	:if(s2==0.0){err=true;return;};		//除法
										mStackOperand.push(s1/s2);
										break;	
                    case kMOD		:if(s2==0.0){err=true;return;};		//求余数
									mStackOperand.push(fmod(s1, s2));
									break;
                    case kPower		:mStackOperand.push(pow(s1, s2));break;	//乘方
                    default:break;
         }//end switch
    }// end if not empty
    top=mStackOperand.top();
    if(op!=kCaculate){	//如果不是是 "等号" ,进入D状态
        this->mStackOperator.push(op);
        mState=_STATE_D_;
    }else{				//否则进入O状态
        this->mState=_STATE_O_;
        mStackOperand.pop();
    }
	//计算结果转换为字符串
    mDisplay.fromDouble(top);
}

/************************************************************************
 *	运算符优先级
 *	加法、加法1级
 *	乘法、除法2级
 *	幂运算    3级
 *	等于号	  0级
 ************************************************************************/
int op_level(int op){
    if(op==kCaculate)
        return 0x00;
    if(op==kPower)
        return 0xf0;
    if (op==kAdd || op==kMinus) {
        return 0x01;
    }else{
        return 0x02;
    }
}
void CAutoMata::reset(){
    //this->mStackOperand.clear();
    //this->mStackOperator.clear();
    while(!mStackOperand.empty()) {
        mStackOperand.pop();
    }
    while(!mStackOperator.empty()){
        mStackOperator.pop();
    }
    this->mDisplay=_K_ZERO_;
    this->mState=_STATE_O_;
    this->err=false;
}
void CAutoMata::error(){
    this->err=true;
}
void CAutoMata::trim0(){
}
/**************************************************
 * 阶乘
 **************************************************/ 
double Fact(double x){
    if(x==0)
        return 1.0;
    double f=1.0;
    while(x>=1){
        f=f*x;
        x--;
    }
    return f;
}