repos_ecs/DrawIDE/IDE/Computer.cpp

// StringResolution.cpp: implementation of the CComputer class.

#include "stdafx.h"
#include "computer.h"
#include <math.h>
#include "kernel.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif



extern int MyRound(double value);

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CComputer::CComputer(char*pszFormula)
:m_nOprandNum(0),m_nOprandANum(0),m_nOperatorNum(0)
{
	m_pOperator = NULL;
	m_pOprand = NULL;
	m_pOprandA = NULL;
	if (pszFormula)
	{
		m_strFormula = pszFormula;
		Initialize();
	}
}

CComputer::~CComputer()
{
	if (m_pOperator)
		delete[]m_pOperator;
	m_pOperator = NULL;

	if(m_pOprand)
		delete[]m_pOprand;
	m_pOprand = NULL;

	if (m_pOprandA)
		delete[]m_pOprandA;
	m_pOprandA = NULL;
}

void CComputer::SetFormula(CString strFormula)
{
	if (!strFormula)
	{
		return;
	}
	m_strFormula = strFormula;
	if (m_pOperator)
	{
		delete[]m_pOperator;
		m_pOperator = NULL;
	}
	if (m_pOprand)
	{
		delete[]m_pOprand;
		m_pOprand = NULL;
	}
	if (m_pOprandA)
	{
		delete[]m_pOprandA;
		m_pOprandA = NULL;
	}
	m_nOprandNum = 0,m_nOprandANum = 0,m_nOperatorNum = 0;
	Initialize();	
}

int CComputer::IsFormula()
{
	stack<char> charStack;
	int i,num = m_strFormula.GetLength();
	char notChar[] = {';','\'',':',' ','[',']','{','}','\\','|',',','\"','&','%','$','@','#','`','~','?'};//'!', modify by 2012.06.01
	int notNum = sizeof(notChar);
	for (i=0;i<num;i++)
	{
		for (int j=0;j<notNum;j++)
		{
			if (m_strFormula[i]==notChar[j])
			{
				CString s;
				s.Format("The %dth character,\"%c\" is invalidated!",i+1,m_strFormula[i]);
				//LOG4C((LOG_NOTICE, "< %s >",s));
				return -i-1;//the ith symbol is invalidating.
			}
		}
	}
	for (i=0;i<num;i++)
	{
		if (m_strFormula[i]=='(')
		{
			charStack.push('(');
		}
		if (m_strFormula[i]==')')
		{
			if (charStack.empty())
			{
				return 1;//right bracket if more.
			}
			else
			{
				charStack.pop();
			}
		}
	}
	if (!charStack.empty())
	{
		return 2;//left bracket is more.
	}
	return 0;
}

BOOL CComputer::GetStack(OperatorStack &Operator, OperandStack &Oprand)
{
	if (IsFormula())
	{
		return FALSE;//illogicality return
	}
	BOOL bRet = TRUE;
	EmptyStack(Operator);
	EmptyStack(Oprand);
	CString str = m_strFormula;
	bRet = bRet&&GetOperatorStack(Operator,str);
	bRet = bRet&&GetOperandStack(Oprand,str);
	return bRet;
}

BOOL CComputer::Initialize()
{
	BOOL bRet = FALSE;
	OperatorStack Op; OperandStack Od;
	bRet = GetStack(Op,Od);
	if (!bRet)
	{
		EmptyStack(Op);
		EmptyStack(Od);
		return FALSE;
	}
	m_nOprandNum = (int)Od.size(),m_nOperatorNum = (int)Op.size();
	if (m_nOperatorNum)
	{
		m_pOperator = new COperator[m_nOperatorNum];
	}
	if (m_nOprandNum)
	{
		m_pOprand = new COperand[m_nOprandNum];
	}

	int i;
	for (i=0;i<m_nOperatorNum;i++)
	{
		COperator*op = Op.top();
		m_pOperator[m_nOperatorNum-i-1] = *op;
		Op.pop();
		delete op;
	}
	for (i=0;i<m_nOprandNum;i++)
	{
		COperand*od = Od.top();
		m_pOprand[m_nOprandNum-i-1] = *od;
		Od.pop();
		delete od;
	}
	m_pOprandA = new COperand[m_nOprandNum];
	BOOL IsIn = FALSE;
	for (i=0;i<m_nOprandNum;i++)
	{
		for (int j=0;j<m_nOprandANum;j++)
		{
			if (m_pOprand[i]==m_pOprandA[j])
			{
				IsIn = TRUE;
				break;
			}
		}
		if (!IsIn&&!m_pOprand[i].m_bIsConst)
		{
			m_pOprandA[m_nOprandANum] = m_pOprand[i];
			m_nOprandANum++;
		}
		IsIn = FALSE;
	}
	return TRUE;
}

double CComputer::Computer(OperatorStack &Operator, OperandStack &Oprand)
{
	double value =0.0;
	if (Operator.empty())
	{
		if (Oprand.size()==1)
		{	
			COperand* od = Oprand.top();
			value = atof(od->m_strName);
			delete od;
			return value;
		}
		else
		{
			while (!Oprand.empty())
			{
				COperand*od = Oprand.top();
				Oprand.pop();
				delete od;
			}
			return BIGNUMBER;
		}
	}
	OperatorStack tmpOO;
	OperandStack tmpOD;
	COperator* op = 0,*op1 = 0;
	COperand *oprand = 0,*oprand1 = 0;
	op = Operator.top();
	Operator.pop();
	if (!Operator.empty())
	{
		op1 = Operator.top();
	}
	while (op1&&(op1->m_nLevel > op->m_nLevel))
	{
		tmpOO.push(op);
		if (op->m_nType==BINARY)
		{
			if (!Oprand.empty())
			{
				oprand = Oprand.top();
				Oprand.pop();
				tmpOD.push(oprand);
			}
		}
		op = op1;
		Operator.pop();
		if (!Operator.empty())
		{
			op1 = Operator.top();
		}
		else
		{
			op1 = 0;
		}
	}
	if (op->m_nType==UNARY)
	{
		if (Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand = Oprand.top();
		double x = computing(op,oprand);
		oprand->m_strName.Format("%g",x);
	}
	else
	{
		if (Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand1 = Oprand.top();
		Oprand.pop();
		if (Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand = Oprand.top();
		double x = computing(op,oprand1,oprand);
		oprand->m_strName.Format("%g",x);
		delete oprand1;
	}
	delete op;
	while (!tmpOO.empty())
	{
		op = tmpOO.top();
		tmpOO.pop();
		Operator.push(op);
	}
	while (!tmpOD.empty())
	{
		oprand = tmpOD.top();
		tmpOD.pop();
		Oprand.push(oprand);
	}
	return Computer(Operator,Oprand);
}

double CComputer::computer(double variantValue[], int num)
{
	double value = 0.0;
	int i;
	if (num<m_nOprandANum)
	{
		//LOG4C((LOG_NOTICE, "computer error"));
		return BIGNUMBER;
	}
	OperatorStack Operator;
	OperandStack Oprand;
	for (i=0;i<m_nOperatorNum;i++)
	{
		COperator*op = new COperator;
		*op = m_pOperator[m_nOperatorNum-i-1];
		Operator.push(op);
	}
	for (i=0;i<m_nOprandNum;i++)
	{
		COperand*od = new COperand;
		*od = m_pOprand[m_nOprandNum-i-1];
		for(int j=0;j<m_nOprandANum;j++)
		{
			if (*od==m_pOprandA[j])
			{
				od->m_strName.Format("%g",variantValue[j]);
			}
		}
		Oprand.push(od);
	}
	value = Computer(Operator,Oprand);
	return value;
}


CString CComputer::GetErrorInformation()
{
	CString value;
	return value;
}


BOOL CComputer::EmptyStack(OperatorStack Op)
{
	while(!Op.empty())
	{
		COperator*op = Op.top();
		Op.pop();
		delete op;
	}
	return TRUE;
}


BOOL CComputer::EmptyStack(OperandStack Od)
{
	while (!Od.empty())
	{
		COperand*od = Od.top();
		Od.pop();
		delete od;
	}
	return TRUE;
}

BOOL CComputer::GetOperatorStack(OperatorStack &Operator, CString &string)
{
	BOOL bRet = TRUE;
	int num = string.GetLength();
	int i = 0;
	int level = 0;
	while (i<num)
	{
		if (string[i]=='(')
		{
			level+=LEVELS;
			string.SetAt(i,'#');
			i++;
		}
		else if (string[i]==')')
		{
			level-=LEVELS;
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='+'||string[i]=='-')
		{
			COperator* op=new COperator;
			op->m_nLevel = level;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			if(i==0||string[i-1]=='#')
			{
				op->m_nType = UNARY;
			}
			else
			{
				op->m_nType = BINARY;
			}
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='*'||string[i]=='/')
		{
			COperator* op = new COperator;
			op->m_nLevel = level+1;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='^')
		{
			COperator* op=new COperator;
			op->m_nLevel = level+2;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string.Mid(i,4)=="SQRT")
		{
			COperator* op=new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "SQRT";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="LOG")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "LOG";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="SIN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "SIN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="COS")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "COS";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="TAN")
		{
			COperator* op=new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "TAN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="COT")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "COT";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,4)=="ASIN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ASIN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=3;
		}
		else if (string.Mid(i,4)=="ACOS")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ACOS";
			op->m_nStartIndex  =  i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=3;
		}
		else if (string.Mid(i,4)=="ATAN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ATAN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=3;
		}
		else
		{
			i++;
		}
	}
	return bRet;
}


BOOL CComputer::GetOperandStack(OperandStack &Oprand, CString &string)
{
	int i = 0;
	int num = string.GetLength();
	while (i<num)
	{
		if (string[i]=='#'||string[i]=='@')
		{
			i++;
		}
		else
		{
			COperand * oprand=new COperand;
			if(isdigit(string[i]))
			{
				oprand->m_bIsConst = TRUE;
			}
			oprand->m_nStartIndex = i;
			BOOL HasPoint = FALSE;
			while (i<num&&string[i]!='#'&&string[i]!='@')
			{
				if (string[i]=='.')
				{
					if (HasPoint)
					{
						if( oprand )
							delete oprand;
						return FALSE;
					}
					else
					{
						HasPoint=TRUE;
					}
				}
				if (oprand->m_bIsConst&&!isdigit(string[i])&&(string[i]!='.'))
				{
					CString s;
					s.Format("Variant cann't start with digital (%d in expression)!",i+1-oprand->m_strName.GetLength());

					if( oprand )
						delete oprand;
					return FALSE;
				}
				oprand->m_strName+=string.Mid(i,1);
				i++;
			}
			Oprand.push(oprand);
		}
	}
	return TRUE;
}

int CComputer::GetErrorNumber()
{
	return 0;
}

double CComputer::computing(const COperator*op,const COperand*oprand)
{
	double x = atof(oprand->m_strName);
	if (op->m_strOperator=="-")
	{
		x = -x;
	}
	else if (op->m_strOperator=="LOG")
	{
		if(x>0)
		{
			x = log(x);
		}
		else
		{
			x = BIGNUMBER;
		}
	}
	else if (op->m_strOperator=="SQRT")
	{
		if ( x>=0 )
		{
			x = sqrt(x);
		}
		else
		{
			x = BIGNUMBER;
		}
	}
	else if (op->m_strOperator=="SIN")
	{
		x = sin(x);
	}
	else if (op->m_strOperator=="COS")
	{
		x = cos(x);
	}
	else if (op->m_strOperator=="TAN")
	{
		x = tan(x);
	}
	else if (op->m_strOperator=="COT")
	{
		if(fabs(sin(x))>DERROR)
		{
			x = cos(x)/sin(x);
		}
		else
		{
			x = BIGNUMBER;
		}
	}
	else if (op->m_strOperator=="ASIN")
	{
		x = asin(x);
	}
	else if (op->m_strOperator=="ACOS")
	{
		x = acos(x);
	}
	else if (op->m_strOperator=="ATAN")
	{
		x = atan(x);
	}
	return x;
}


double CComputer::computing(const COperator*op,const COperand*Loprand,const COperand*Roprand)
{
	double x = BIGNUMBER;
	switch(op->m_strOperator[0])
	{
	case '+':
		x = atof(Loprand->m_strName)+atof(Roprand->m_strName);
		break;
	case '-':
		x = atof(Loprand->m_strName)-atof(Roprand->m_strName);
		break;
	case '*':
		x = atof(Loprand->m_strName)*atof(Roprand->m_strName);
		break;
	case '/':
		{
			double y = atof(Roprand->m_strName);
			x = atof(Loprand->m_strName);
			if (fabs(y)>DERROR)
			{
				x = x/y;
			}
			else
			{
				x = BIGNUMBER;
			}
		}
		break;
	case '^':
		{
			double y = atof(Roprand->m_strName);
			x = atof(Loprand->m_strName);
			x = pow(x,y);
		}
		break;
	}
	return x;
}

CString CComputer::GetDigitalString(double* variantValue,int num)
{
	CString value=m_strFormula;
	if (num>=m_nOprandANum)
	{
		int i,j;
		CString* ppchar;
		ppchar=new CString[m_nOprandNum+1];
		for (i=0;i<=m_nOprandNum;i++)
		{
			if (i==0)
			{
				ppchar[0]=m_strFormula.Left(m_pOprand[0].m_nStartIndex);
			}
			else if (i<m_nOprandNum)
			{
				WORD start=m_pOprand[i-1].m_nStartIndex+m_pOprand[i-1].m_strName.GetLength();
				WORD length=m_pOprand[i].m_nStartIndex-start;
				ppchar[i]=m_strFormula.Mid(start,length);
			}
			else
			{
				WORD start=m_pOprand[i-1].m_nStartIndex+m_pOprand[i-1].m_strName.GetLength();
				ppchar[i]=m_strFormula.Mid(start);
			}
		}
		CString* digitchar = new CString[m_nOprandNum];
		for (i=0;i<m_nOprandNum;i++)
		{
			if (m_pOprand[i].m_bIsConst)
			{
				digitchar[i]=m_pOprand[i].m_strName;
			}
			else
			{
				for (j=0;j<m_nOprandANum;j++)
				{
					if (m_pOprand[i]==m_pOprandA[j])
					{
						if (variantValue[j]<0)
						{
							digitchar[i].Format("(%g)",variantValue[j]);
						}
						else
						{
							digitchar[i].Format("%g",variantValue[j]);
						}
					} // end if
				} // end for
			} // end else
		}

		value = ppchar[0];
		for (i=0;i<m_nOprandNum;i++)
		{
			value += digitchar[i]+ppchar[i+1];
		}
		delete[]ppchar;
		delete[]digitchar;
	}
	return value;
}


BOOL CComputer::ExpressionIsError()
{
#ifndef _ERROR_INFO_H_
	return 0;
#else
	GET_EXPRESSION_ERROR 
#endif
}


const COperand* CComputer::GetVariantTable()
{
	return m_pOprandA;
}


COperator::COperator():m_nStartIndex(0),m_nLevel(0),m_nType(BINARY)
{
}


COperator::~COperator()
{
}


COperand::COperand():m_nStartIndex(0)
{
	m_bIsConst = FALSE;
}


COperand::~COperand()
{
}


BOOL COperand::operator ==(const COperand & od)
{
	BOOL bRet=TRUE;
	bRet = (m_bIsConst==od.m_bIsConst);
	bRet = (bRet&&(m_strName==od.m_strName));
	return bRet;
}

void CComputer::Destroy()
{
	if (m_pOperator)
	{
		delete[]m_pOperator;
		m_pOperator = NULL;
	}
	if (m_pOprand)
	{
		delete[]m_pOprand;
		m_pOprand = NULL;
	}
	if (m_pOprandA)
	{
		delete[]m_pOprandA;
		m_pOprandA = NULL;
	}
	m_nOprandNum=0;
	m_nOprandANum=0;
	m_nOperatorNum=0;
}


BOOL CRealComputer::GetOperatorStack(OperatorStack&Operator,CString &string)
{
	BOOL bRet = TRUE;
	int num = string.GetLength();
	int i = 0;
	int level = 0;
	while (i<num)
	{
		if (string[i]=='(')
		{
			level+=LEVELS;
			string.SetAt(i,'#');
			i++;
		}
		else if (string[i]==')')
		{
			level-=LEVELS;
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='+'||string[i]=='-')
		{
			COperator* op = new COperator;
			op->m_nLevel = level;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			if(i==0||string[i-1]=='#')
			{
				op->m_nType=UNARY;
			}
			else
			{
				op->m_nType = BINARY;
			}
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='*'||string[i]=='/')
		{
			COperator* op = new COperator;
			op->m_nLevel = level+1;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='^')
		{
			COperator* op = new COperator;
			op->m_nLevel = level+2;
			op->m_strOperator = string.Mid(i,1);
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string.Mid(i,4)=="SQRT")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "SQRT";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=4;
		}
		else if (string.Mid(i,3)=="LOG")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "LOG";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="SIN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "SIN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="COS")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "COS";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="TAN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "TAN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="COT")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "COT";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,4)=="ASIN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ASIN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=4;
		}
		else if (string.Mid(i,4)=="ACOS")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ACOS";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=4;
		}
		else if (string.Mid(i,4)=="ATAN")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ATAN";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');string.SetAt(i+3,'@');
			i+=4;
		}
		else if (string.Mid(i,3)=="ABS")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "ABS";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="MOD")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "MOD";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="RND")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "RND";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,2)=="==")
		{
			COperator* op = new COperator;
			op->m_nLevel=3+level;
			op->m_strOperator = "==";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');
			i+=2;
		}
		else if (string.Mid(i,2)==">=")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = ">=";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');
			i+=2;
		}
		else if (string.Mid(i,2)=="<=")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "<=";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');
			i+=2;
		}
		else if (string.Mid(i,2)=="!=")//modify by 2012.06.01 <>
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "!=";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');
			i+=2;
		}
		else if (string[i]=='>')
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = ">";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string[i]=='<')
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "<";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');
			i++;
		}
		else if (string.Mid(i,3)=="NOT")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "NOT";
			op->m_nStartIndex = i;
			op->m_nType = UNARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,3)=="AND")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "AND";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else if (string.Mid(i,2)=="OR")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "OR";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');
			i+=2;
		}
		else if (string.Mid(i,3)=="XOR")
		{
			COperator* op = new COperator;
			op->m_nLevel = 3+level;
			op->m_strOperator = "XOR";
			op->m_nStartIndex = i;
			op->m_nType = BINARY;
			Operator.push(op);
			string.SetAt(i,'@');string.SetAt(i+1,'@');string.SetAt(i+2,'@');
			i+=3;
		}
		else
		{
			i++;
		}
	}
	return bRet;
}


double CRealComputer::computing(const COperator*op,const COperand*oprand)
{
	double x = atof(oprand->m_strName);
	if (op->m_strOperator=="-")
	{
		x = -x;
	}
	else if (op->m_strOperator=="SQRT")
	{
		if (x>=0)
		{
			x = sqrt(x);
		}
		else
		{
			x = BIGNUMBER;
		}
	}
	else if (op->m_strOperator=="SIN")
	{
		x = sin(x);
	}
	else if (op->m_strOperator=="COS")
	{
		x = cos(x);
	}
	else if (op->m_strOperator=="TAN")
	{
		x = tan(x);
	}
	else if (op->m_strOperator=="COT")
	{
		if (fabs(sin(x))>DERROR)
		{
			x = cos(x)/sin(x);
		}
		else
		{
			x = BIGNUMBER;
		}
	}
	else if (op->m_strOperator=="NOT")
	{
		if (x!=0)
		{
			x = 0;
		}
		else
		{
			x = 1;
		}
	}
	else if (op->m_strOperator=="RND")
	{
		x = (int)x;
	}
	return x;
}


double CRealComputer::computing(const COperator*op,const COperand*Loprand,const COperand*Roprand)
{
	double x = BIGNUMBER;
	switch (op->m_strOperator[0])
	{
	case '+':
		x = atof(Loprand->m_strName)+atof(Roprand->m_strName);
		break;
	case '-':
		x = atof(Loprand->m_strName)-atof(Roprand->m_strName);
		break;
	case '*':
		x = atof(Loprand->m_strName)*atof(Roprand->m_strName);
		break;
	case '/':
		{
			double y = atof(Roprand->m_strName);
			x = atof(Loprand->m_strName);
			if (fabs(y)>DERROR)
			{
				x = x/y;
			}
			else
			{
				x = BIGNUMBER;
			}
		}
		break;
	case '^':
		{
			double y = atof(Roprand->m_strName);
			x = atof(Loprand->m_strName);
			x = pow(x,y);
		}
		break;
	}

	if (op->m_strOperator=="==")
	{
		if (MyRound(atof(Loprand->m_strName)) == MyRound(atof(Roprand->m_strName)) )
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator==">=")
	{
		if (atof(Loprand->m_strName)>=atof(Roprand->m_strName))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator=="<=")
	{
		if (atof(Loprand->m_strName)<=atof(Roprand->m_strName))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator=="!=")
	{
		if (atof(Loprand->m_strName)!=atof(Roprand->m_strName))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator==">")
	{
		if (atof(Loprand->m_strName)>atof(Roprand->m_strName))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator=="<")
	{
		if (atof(Loprand->m_strName)<atof(Roprand->m_strName))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator=="AND")
	{
		if (MyRound(atof(Loprand->m_strName)) && MyRound(atof(Roprand->m_strName)))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if (op->m_strOperator=="OR")
	{
		if (MyRound(atof(Loprand->m_strName)) || MyRound(atof(Roprand->m_strName)))
		{
			x = 1;
		}
		else
		{
			x = 0;
		}
	}
	else if(op->m_strOperator=="XOR")
	{
		if (MyRound(atof(Loprand->m_strName))&&MyRound(atof(Roprand->m_strName)))
		{
			x = 0;
		}
		else if ((!MyRound(atof(Loprand->m_strName))) && (!MyRound(atof(Roprand->m_strName))))
		{
			x = 0;
		}
		else
		{
			x = 1;
		}
	}
	else if (op->m_strOperator=="MOD")
	{
		x  =MyRound(atof(Loprand->m_strName)) % MyRound(atof(Roprand->m_strName));
	}
	return x;
}


int CRealComputer::IsFormula()
{
	stack<char> charStack;
	int i,num=m_strFormula.GetLength();
	char notChar[] = {';','\'',':',' ','[',']','{','}','\\','|',',','&','%','$','@','#','`','~','?'};//'!', modify by 2012.06.01
	int notNum = sizeof notChar;
	for (i=0;i<num;i++)
	{
		for (int j=0;j<notNum;j++)
		{
			if (m_strFormula[i]==notChar[j])
			{
				CString s;
				s.Format("The %dth character,\"%c\" is invalidated!",i+1,m_strFormula[i]);
				return -i-1;//the ith symbol is invalidating.
			}
		}
	}
	for (i=0;i<num;i++)
	{
		if (m_strFormula[i]=='(')
		{
			charStack.push('(');
		}
		if (m_strFormula[i]==')')
		{
			if (charStack.empty())
			{
				return 1;//right bracket if more.
			}
			else
			{
				charStack.pop();
			}
		}
	}

	if (!charStack.empty())
	{
		return 2; //left bracket is more.
	}
	return 0;
}


double  CRealComputer::GetResult()
{
    double data[100] = {0.0};
	for (int i=0;i<m_nOprandANum;i++)
	{
		float tmp = 0.0;//pVariantsManager->GetAnalogValue(m_pOprandA[i].m_strName);
		//if( -1 != m_formula.Find("Caross_1_StartORShutStatus") )
		//	LOG4C((LOG_NOTICE, "m_strDynShow = < %s >,m_oprandA[i].m_name=%s, m_oprandANum = %d",m_formula,m_oprandA[i].m_name,m_oprandANum ));
		if ( (int)tmp!=VARIANT_NOTFOUND )
		{	
			data[i] = tmp;
		}
		else
		{
			
		}
	}
	double result = computer(data, m_nOprandANum);
	return result;
}