block.h

支持简单的公式推导

#ifndef __BLOCK_H__
#define __BLOCK_H__

#include "cluster.h"

class Block : public Operand
{

public: 
    	
	Block(const  Cluster& c);
	Block(double in = 0):last_me_(NULL)
	{
		/**this = Block(Cluster(in));*/ // not allowed!!!
		//*this = Block(Cluster(in));
		cluster_set_.insert(Cluster(in));
	    UpdateAll();  
	}
	
	~Block()
	{   
		//cout<<"in ~B\n";
		if (last_me_ != NULL) 
			delete last_me_;
		last_me_ = NULL;
		expression_.erase();
		cluster_set_.clear();
	}

	//Block(const string& str):last_me_(NULL){*this = Block(Cluster(str));} !!!!????
	Block(const string& str):last_me_(NULL)
	{   
		cluster_set_.insert(Cluster(str));
        cluster_set_.insert(Cluster(0));
		UpdateAll(); 
	}

    Block(const Block& l);
	
    
public:
	
     Block& Mul(const Block&);//处理内务！！！
     Block& Add(const Block&);//处理内务！！！
     Block& Sub(const Block&); 
public://inline
    virtual bool IsConst()const
		{return cluster_set_.size() == 1;}
    bool HasSingleFactor()const
	{
		return  ( fabs(GetSingleValue()) < c_very_small   //单项变量
			                     && cluster_set_.size() == 2 )
		       ;						 
	}
    virtual string GetExpression()const
		{ return expression_;} 
   
	virtual double GetSingleValue()const
	{
		return cluster_set_.begin()->GetSingleValue();// pp1
	}
	
   void ReplaceByConst(const string&,double );
   virtual Block& PowerBy(double );
   Block& operator=(const Block& l);
public:
        
    set<Cluster> cluster_set_; // not map!!!
    void MulCluster(const Cluster& n);
private:
	void UpdateAll();
	
    void ExpressionCut(string&);
   	void ReverseAllWeight();
private:
    string expression_;
	//为了实现复杂符号比如开方之类引入一个堆栈！！
	//vector<Block> block_stack_; //因为block不一定能power!!!
	Block* last_me_;
};
string ForMul(const string& postfix,double times);
string ForSum(double,const string frame);
//------------------------------------------------
Block operator +(const Block& lb,const Block rb);
//Block& operator +=(const Block& lb);
Block operator -(const Block& lb,const Block rb);
Block operator *(const Block& lb,const Block rb);
Block operator ^(const Block& lb,int n);
Block operator /(const Block& lb,const Block rb);
//Block Power(const Block& lb,double p);
Block operator -(const Block& lb);
//------------------------------------------------
vector<Block> AssignFactor(const Block& block, const Block& node);
Block         Delta(const vector<Block>& vb);
pair<Block,Block> Root_2(const vector<Block>& vb);         






#endif //__BLOCK_H__