automata.cpp

Windows CE上的计算器

#include "StdAfx.h"
#include <cmath>
#include "automata.h"
#include "constant.h"

const char _K_ZERO_[]="0";
const char _K_PI[]="3.1415926535897932384626433832795";
const char _K_E[] ="2.7182818284590452353602874713527";
#ifndef M_PI
#define M_PI (3.1415926535897932384626433832795)
#endif

const int _STATE_O_=0xF0;	//
const int _STATE_A_=0xF1;	// No Dot
const int _STATE_B_=0xF2;	// Dot
const int _STATE_C_=0xF3;	// Single Operation, 1/x,sin,cos,...
const int _STATE_D_=0xF4;	// Binary,..., + - * / ^
const int _STATE_E_=0xF5;	// ( clicked
const int _STATE_ERR_=-0xFF;

double Fact(double x);//Fact(n)=n!
/*
 *	初始化
 *  清零
 */
CAutoMata::CAutoMata() {
    this->mState=_STATE_O_;
    this->mDisplay=_K_ZERO_;
    this->err=false;
}
CAutoMata::~CAutoMata() {
    //Nothing TODO
}
/*
 *	默认为弧度
 */
#include <string>
int CAutoMata::acceptInstruction(int data){
    return CAutoMata::acceptInstruction(data, RAD);

}
/*********************************************************
 * 状态转移、计算功能的实现的实现
 *********************************************************/ 
int CAutoMata::acceptInstruction(int data, int type){
    if(err && data!=kReset)
        return ST_IGNORE;
    int tmp_len;/*Warning... Do Not Use it*/
    double value=mDisplay.toDouble();
    switch (data) {
/*********************************************************/ 
        case '0':
            switch (mState) {
                case _STATE_O_:
                    return ST_IGNORE;	//直接忽略
                case _STATE_A_:
                case _STATE_B_:
                    this->mDisplay.append(_K_ZERO_);
                    return ST_UPDATE_DISPLAY;//更新显示
                case _STATE_C_:
                case _STATE_D_:
                    this->mState=_STATE_O_;
                    this->mDisplay=_K_ZERO_;
                    return ST_UPDATE_DISPLAY;
            }
            break;
/*********************************************************/ 
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            switch (mState) {
                case _STATE_O_:
                case _STATE_C_:
                case _STATE_D_:
                    mDisplay.clear();
                    mDisplay.append(data);
                    mState=_STATE_A_;
                    return ST_UPDATE_DISPLAY;
                case _STATE_A_:mDisplay.append(data);break;
                case _STATE_B_:
                    mDisplay.append(data);
                    /****************************************
                     *		(*^_^*)	East Egg Here!			*
                     *		Don't Tell Others,Ha ha 		*
                     ****************************************/
                    if(mDisplay.compare(_K_PI)==0)
                        return __EASTER_EGG__;
                    return ST_UPDATE_DISPLAY;
            }
            break;
/*********************************************************/ 
        case kDot:
            switch(mState){
                case _STATE_O_:
                case _STATE_A_:
                    mDisplay.append('.');
                    mState=_STATE_B_;
                    return ST_UPDATE_DISPLAY;
                case _STATE_B_:
                    return ST_IGNORE;// X.... => X.忽略多余的小数点
                case _STATE_C_:
                case _STATE_D_:
                    mDisplay.clear();
                    mDisplay.append('0');
                    mDisplay.append('.');
                    mState=_STATE_B_;
                    return ST_UPDATE_DISPLAY;
            }
            break;
/*********************************************************/ 
        case kAdd:
        case kMinus:
        case kMuliply:
        case kDivide:
        case kMOD:
        case kPower:
            switch (mState)	{
                /*	忽略多余的运算符，保留最后输入的
                 *	If input 4+-+-*-3
                 *	We will ignore  the previous operators
                 *  Only Calculate 4-3
                 */
                case _STATE_D_:
                    this->mStackOperator.pop();
                    this->mStackOperator.push(data);
                    return ST_IGNORE;
            }
            
            updateStack(data);
            this->mState=_STATE_D_;
            return ST_UPDATE_DISPLAY;
            break;
/*********************************************************/ 
        case kLeftBracket:
            switch(mState){
                case _STATE_O_:
                case _STATE_D_:
                    mState=_STATE_E_;
                    mStackOperator.push(kLeftBracket);
                    return ST_UPDATE_BRACKET;
                    break;
                case _STATE_A_:
                case _STATE_B_:
                case _STATE_C_:break;
            }
/*********************************************************/ 
        case kSquareRoot:
            if (value<0){
                this->error();
                return ST_UPDATE_DISPLAY;
            }
            value=sqrt( value );
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kFactorial:
            if (value<0||value>70){//阶乘参数范围
                this->error();
                return ST_UPDATE_DISPLAY;
            }
            value=Fact(value);
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kReciprocal:
            if (value==0.0)	{	//0没有倒数
                mState=_STATE_ERR_;
                this->error();
                return ERR_DIV_BY_ZERO;
            }
            value=1.0/( value );
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kCaculate:
            updateStack(kCaculate);
            mState=_STATE_C_;
            break;
        case kSign:
            if (!mDisplay.compare(_K_ZERO_))
                break;
            if (mDisplay.at(0)=='-')
                mDisplay.deletefirst();
            else
                mDisplay.insertfirst('-');
            break;
        case kSine:
            if(type==DEG){
                value=value/180*M_PI;
            }
            else if(type==GRD){
                value=value/200*M_PI;
            }
            value=sin( value );
            
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kArcSine:
            if(fabs(value)>1.0){
                this->error();
                break;
            }
            value=asin( 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 kCosine:
            
            if(type==DEG){value=value/180*M_PI;}
            else
                if(type==GRD){value=value/200*M_PI;}
            value=cos( value );
            mDisplay.fromDouble(value);
            mState=_STATE_C_;
            break;
        case kArcCosine:
            if(fabs(value)>1.0){
                this->error();
                break;
            }
            value=acos( value );
            if(type==DEG)
                value=value*180/M_PI;
            else if(type==GRD)
                value=value*200/M_PI;