function.cpp

表达式计算expression evaluate expression evaluate expression evaluate

/******************************************************************************
文件名          :Function.cpp
版本号          : 1.0
作者            : Amos Peng
生成日期        :2008-07-08
最近修改        :
功能描述        :自定义函数的工厂子类及其节点子类
函数列表        :

*******************************************************************************/
// Includes
#include <new>
#include <memory>

#include <cmath>
#include <cerrno>
#include <ctime>

#include "defs.h"
#include "funclist.h"
#include "node.h"
#include "except.h"

using namespace std;
using namespace ExprEval;

// Anonymous namespace for items
namespace
{
    // Absolute value
    //--------------------------------------------------------------------------
    class abs_FunctionNode : public CFunctionNode
    {
    public:
        abs_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            return fabs(m_nodes[0]->Evaluate());
        }
    };
        
    class abs_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "abs";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new abs_FunctionNode(expr);
        }
    };
        
    // Modulus
    //--------------------------------------------------------------------------
    class mod_FunctionNode : public CFunctionNode
    {
    public:
        mod_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            double result;
            
            // Check for math errors
            errno = 0;
            
            result = fmod(m_nodes[0]->Evaluate(), m_nodes[1]->Evaluate());
            if(errno)
                throw(CMathException(GetName()));
                
            return result;
        }
    };
        
    class mod_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "mod";
        }

        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new mod_FunctionNode(expr);
        }
    };
        
    // Integer part
    //--------------------------------------------------------------------------
    class ipart_FunctionNode : public CFunctionNode
    {
    public:
        ipart_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            double result;
            
            modf(m_nodes[0]->Evaluate(), &result);
                
            return result;
        }
    };
        
    class ipart_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "ipart";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new ipart_FunctionNode(expr);
        }
    };
                
    // Fraction part
    //--------------------------------------------------------------------------
    class fpart_FunctionNode : public CFunctionNode
    {
    public:
        fpart_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            double dummy;
            
            return modf(m_nodes[0]->Evaluate(), &dummy);
        }
    };
        
    class fpart_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "fpart";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new fpart_FunctionNode(expr);
        }
    };        
        
    // Minimum
    //--------------------------------------------------------------------------
    class min_FunctionNode : public CFunctionNode
    {
    public:
        min_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, -1, 0, 0);
        }
    
        double DoEvaluate()
        {
            ::std::vector<CNode*>::size_type pos;
            
            double result = m_nodes[0]->Evaluate();
            
            for(pos = 1; pos < m_nodes.size(); pos++)
            {
                double tmp = m_nodes[pos]->Evaluate();
                if(tmp < result)
                    result = tmp;
            }
                
            return result;
        }
    };
        
    class min_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "min";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new min_FunctionNode(expr);
        }
    };        
        
    // Maximum
    //--------------------------------------------------------------------------
    class max_FunctionNode : public CFunctionNode
    {
    public:
        max_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, -1, 0, 0);
        }
    
        double DoEvaluate()
        {
            ::std::vector<CNode*>::size_type pos;
            
            double result = m_nodes[0]->Evaluate();
            
            for(pos = 1; pos < m_nodes.size(); pos++)
            {
                double tmp = m_nodes[pos]->Evaluate();
                if(tmp > result)
                    result = tmp;
            }
                
            return result;
        }
    };
        
    class max_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "max";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new max_FunctionNode(expr);
        }
    };        
        
    // Square root
    //--------------------------------------------------------------------------
    class sqrt_FunctionNode : public CFunctionNode
    {
    public:
        sqrt_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = sqrt(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class sqrt_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "sqrt";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new sqrt_FunctionNode(expr);
        }
    };
        
    // Sine
    //--------------------------------------------------------------------------
    class sin_FunctionNode : public CFunctionNode
    {
    public:
        sin_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = sin(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class sin_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "sin";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new sin_FunctionNode(expr);
        }
    };
        
    // Cosine
    //--------------------------------------------------------------------------
    class cos_FunctionNode : public CFunctionNode
    {
    public:
        cos_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = cos(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class cos_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "cos";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new cos_FunctionNode(expr);
        }
    };
        
    // Tangent
    //--------------------------------------------------------------------------
    class tan_FunctionNode : public CFunctionNode
    {
    public:
        tan_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = tan(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class tan_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "tan";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new tan_FunctionNode(expr);
        }
    };
        
    // Hyperbolic Sine
    //--------------------------------------------------------------------------
    class sinh_FunctionNode : public CFunctionNode
    {
    public:
        sinh_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = sinh(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class sinh_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "sinh";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new sinh_FunctionNode(expr);
        }
    };
        
    // Hyperbolic Cosine
    //--------------------------------------------------------------------------
    class cosh_FunctionNode : public CFunctionNode
    {
    public:
        cosh_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = cosh(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class cosh_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "cosh";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new cosh_FunctionNode(expr);
        }
    };
        
    // Hyperbolic Tangent
    //--------------------------------------------------------------------------
    class tanh_FunctionNode : public CFunctionNode
    {
    public:
        tanh_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = tanh(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class tanh_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "tanh";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new tanh_FunctionNode(expr);
        }
    };
        
    // Arc Sine
    //--------------------------------------------------------------------------
    class asin_FunctionNode : public CFunctionNode
    {
    public:
        asin_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = asin(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class asin_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "asin";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new asin_FunctionNode(expr);
        }
    };
        
    // Arc Cosine
    //--------------------------------------------------------------------------
    class acos_FunctionNode : public CFunctionNode
    {
    public:
        acos_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);