function.cpp

表达式计算expression evaluate expression evaluate expression evaluate

        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = acos(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class acos_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "acos";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new acos_FunctionNode(expr);
        }
    };
        
    // Arc Tangent
    //--------------------------------------------------------------------------
    class atan_FunctionNode : public CFunctionNode
    {
    public:
        atan_CFunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = atan(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class atan_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "atan";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new atan_FunctionNode(expr);
        }
    };
        
    // Arc Tangent 2: atan2(y, x)
    //--------------------------------------------------------------------------
    class atan2_FunctionNode : public CFunctionNode
    {
    public:
        atan2_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = atan2(m_nodes[0]->Evaluate(), m_nodes[1]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class atan2_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "atan2";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new atan2_FunctionNode(expr);
        }
    };
        
    // Log
    //--------------------------------------------------------------------------
    class log_FunctionNode : public CFunctionNode
    {
    public:
        log_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = log10(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class log_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "log";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new log_FunctionNode(expr);
        }
    };
        
    // Ln
    //--------------------------------------------------------------------------
    class ln_FunctionNode : public CFunctionNode
    {
    public:
        ln_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = log(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class ln_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "ln";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new ln_FunctionNode(expr);
        }
    };
        
    // Exp
    //--------------------------------------------------------------------------
    class exp_FunctionNode : public CFunctionNode
    {
    public:
        exp_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double result = exp(m_nodes[0]->Evaluate());
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class exp_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "exp";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new exp_FunctionNode(expr);
        }
    };
        
    // Logn
    //--------------------------------------------------------------------------
    class logn_FunctionNode : public CFunctionNode
    {
    public:
        logn_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            // Check for division by zero
            double tmp = log(m_nodes[1]->Evaluate());
            
            if(tmp == 0.0)
                throw(CMathException(GetName()));
                
            // Calculate result
            double result = log(m_nodes[0]->Evaluate()) / tmp;
            
            if(errno)
                throw(CMathException(GetName()));
            
            return result;
        }
    };
        
    class logn_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "logn";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new logn_FunctionNode(expr);
        }
    };
        
    // Ceil
    //--------------------------------------------------------------------------
    class ceil_FunctionNode : public CFunctionNode
    {
    public:
        ceil_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            return ceil(m_nodes[0]->Evaluate());
        }
    };
        
    class ceil_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "ceil";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new ceil_FunctionNode(expr);
        }
    };
        
    // Floor
    //--------------------------------------------------------------------------
    class floor_FunctionNode : public CFunctionNode
    {
    public:
        floor_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            return floor(m_nodes[0]->Evaluate());
        }
    };
        
    class floor_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "floor";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new floor_FunctionNode(expr);
        }
    };
        
    // Rand
    //--------------------------------------------------------------------------
    
    // Get next random (0,1)
    inline double NextRandom(double *seed)
    {
        long a = (long)(*seed) * 214013L + 2531011L;
        *seed = (double)a;
        
        return (double)((a >> 16) & 0x7FFF) / 32767.0;
    }
    
    class rand_FunctionNode : public CFunctionNode
    {
    public:
        rand_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(0, 0, 1, 1);
        }
    
        double DoEvaluate()
        {
            return NextRandom(m_refs[0]);
        }
    };
        
    class rand_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "rand";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new rand_FunctionNode(expr);
        }
    };
        
    // Random
    //--------------------------------------------------------------------------
    class random_FunctionNode : public CFunctionNode
    {
    public:
        random_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 1, 1);
        }
    
        double DoEvaluate()
        {
            double a = m_nodes[0]->Evaluate();
            double b = m_nodes[1]->Evaluate();
            
            return NextRandom(m_refs[0]) * (b - a) + a;
        }
    };
        
    class random_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "random";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new random_FunctionNode(expr);
        }
    };        
        
    // Randomize
    //--------------------------------------------------------------------------
    class randomize_FunctionNode : public CFunctionNode
    {
    public:
        randomize_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(0, 0, 1, 1);
        }
    
        double DoEvaluate()
        {
            static long curcall = 1;
            
            *m_refs[0] = (double)(((clock() + 1024u + curcall) * time(NULL)) % 2176971487u);
            curcall++;
            
            return 0.0;
        }
    };
        
    class randomize_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "randomize";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new randomize_FunctionNode(expr);
        }
    };
        
    // Radians to degrees
    //--------------------------------------------------------------------------
    class deg_FunctionNode : public CFunctionNode
    {
    public:
        deg_CFunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            return (m_nodes[0]->Evaluate() * 180.0) / M_PI;
        }
    };
        
    class deg_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "deg";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new deg_FunctionNode(expr);
        }
    };
        
    // Degrees to radians
    //--------------------------------------------------------------------------
    class rad_CFunctionNode : public FunctionNode
    {
    public:
        rad_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            return (m_nodes[0]->Evaluate() * M_PI) / 180.0;
        }
    };
        
    class rad_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "rad";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new rad_FunctionNode(expr);
        }
    };
        
    // Rectangular to polar: rect2pol(x, y, &distance, &angle)
    //--------------------------------------------------------------------------
    class rect2pol_FunctionNode : public FunctionNode
    {
    public:
        rect2pol_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(2, 2, 2, 2);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double x = m_nodes[0]->Evaluate();
            double y = m_nodes[1]->Evaluate();
            
            double d = sqrt(x * x + y * y);
            double a = atan2(y, x);
            
            if(errno)
                throw(CMathException(GetName()));
                
            *m_refs[0] = d;
            if(a < 0.0)
                *m_refs[1] = a + (2.0 * M_PI);
            else
                *m_refs[1] = a;
                
            return d;
        }
    };
        
    class rect2pol_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "rect2pol";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new rect2pol_FunctionNode(expr);
        }
    };
        
    // Polar to rectangular: pol2rect(distance, angle, &x, &y)
    //--------------------------------------------------------------------------
    class pol2rect_FunctionNode : public FunctionNode
    {
    public:
        pol2rect_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(2, 2, 2, 2);
        }
    
        double DoEvaluate()
        {
            errno = 0;
            
            double d = m_nodes[0]->Evaluate();
            double a = m_nodes[1]->Evaluate();