function.cpp

表达式计算expression evaluate expression evaluate expression evaluate

            double x = d * cos(a);
            double y = d * sin(a);
            
            if(errno)
                throw(CMathException(GetName()));
                
            *m_refs[0] = x;
            *m_refs[1] = y;
                
            return x;
        }
    };
        
    class pol2rect_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "pol2rect";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new pol2rect_FunctionNode(expr);
        }
    };
        
    // If
    //--------------------------------------------------------------------------
    class if_FunctionNode : public FunctionNode
    {
    public:
        if_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(3, 3, 0, 0);
        }
    
        double DoEvaluate()
        {
            double c = m_nodes[0]->Evaluate();
            
            if(c == 0.0)
                return m_nodes[2]->Evaluate();
            else
                return m_nodes[1]->Evaluate();
        }
    };
        
    class if_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "if";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new if_FunctionNode(expr);
        }
    };
        
    // Select
    //--------------------------------------------------------------------------
    class select_FunctionNode : public FunctionNode
    {
    public:
        select_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(3, 4, 0, 0);
        }
    
        double DoEvaluate()
        {
            double c = m_nodes[0]->Evaluate();
            
            if(c < 0.0)
                return m_nodes[1]->Evaluate();
            else if(c == 0.0)
                return m_nodes[2]->Evaluate();
            else
            {
                if(m_nodes.size() == 3)
                    return m_nodes[2]->Evaluate();
                else
                    return m_nodes[3]->Evaluate();
            }
        }
    };
        
    class select_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "select";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new select_FunctionNode(expr);
        }
    };
        
    // Equal
    //--------------------------------------------------------------------------
    class equal_FunctionNode : public FunctionNode
    {
    public:
        equal_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() == m_nodes[1]->Evaluate())
                return 1.0;
            else
                return 0.0;
        }
    };
        
    class equal_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "equal";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new equal_FunctionNode(expr);
        }
    };
        
    // Above
    //--------------------------------------------------------------------------
    class above_FunctionNode : public FunctionNode
    {
    public:
        above_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() > m_nodes[1]->Evaluate())
                return 1.0;
            else
                return 0.0;
        }
    };
        
    class above_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "above";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new above_FunctionNode(expr);
        }
    };
        
    // Below
    //--------------------------------------------------------------------------
    class below_FunctionNode : public FunctionNode
    {
    public:
        below_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() < m_nodes[1]->Evaluate())
                return 1.0;
            else
                return 0.0;
        }
    };
        
    class below_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "below";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new below_FunctionNode(expr);
        }
    };
        
    // Clip
    //--------------------------------------------------------------------------
    class clip_FunctionNode : public FunctionNode
    {
    public:
        clip_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(3, 3, 0, 0);
        }
    
        double DoEvaluate()
        {
            double v = m_nodes[0]->Evaluate();
            double a = m_nodes[1]->Evaluate();
            double b = m_nodes[2]->Evaluate();
            
            if(v < a)
                return a;
            else if(v > b)
                return b;
            else
                return v;
        }
    };
        
    class clip_FunctionFactory : public FunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "clip";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new clip_FunctionNode(expr);
        }
    };
        
    // Clamp
    //--------------------------------------------------------------------------
    class clamp_FunctionNode : public CFunctionNode
    {
    public:
        clamp_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(3, 3, 0, 0);
        }
    
        double DoEvaluate()
        {
            double v = m_nodes[0]->Evaluate();
            double a = m_nodes[1]->Evaluate();
            double b = m_nodes[2]->Evaluate();
            
            if(a == b)
                return a;
            else
            {
                double tmp = fmod(v - a, b - a);
                
                if(tmp < 0)
                    return tmp + b;
                else
                    return tmp + a;
            }
        }
    };
        
    class clamp_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "clamp";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new clamp_FunctionNode(expr);
        }
    };
        
    // Rescale
    //--------------------------------------------------------------------------
    class rescale_FunctionNode : public CFunctionNode
    {
    public:
        rescale_FunctionNode(CExpression *expr) : FunctionNode(expr)
        {
            SetArgumentCount(5, 5, 0, 0);
        }
    
        double DoEvaluate()
        {
            double pnt = m_nodes[0]->Evaluate();
            double o1 = m_nodes[1]->Evaluate();
            double o2 = m_nodes[2]->Evaluate();
            double n1 = m_nodes[3]->Evaluate();
            double n2 = m_nodes[4]->Evaluate();
            
            double odiff = o2 - o1;
            if(odiff == 0.0)
                return n1;
            else
            {
                return (pnt - o1) * (n2 - n1) / odiff + n1;
            }
        }
    };
        
    class rescale_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "rescale";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new rescale_FunctionNode(expr);
        }
    };
        
    // Poly: poly(x, c3, c2, c1, c0): c3*x^3 + c2*x^2 + c1*x + c0
    //--------------------------------------------------------------------------
    class poly_FunctionNode : public CFunctionNode
    {
    public:
        poly_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, -1, 0, 0);
        }
    
        double DoEvaluate()
        {
            double total = 0.0;
            double curpow;
            
            vector<Node*>::size_type pos, count;
            count = m_nodes.size();
            
            curpow = (double)(count - 2);
            
            // Value of x
            double x = m_nodes[0]->Evaluate();
            
            errno = 0;
            
            for(pos = 1; pos < count; pos++)
            {
                total += (m_nodes[pos]->Evaluate() * pow(x, curpow));
                curpow -= 1.0;
            }
                
            if(errno)
                throw(CMathException(GetName()));
                
            return total;
        }
    };
        
    class poly_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "poly";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new poly_FunctionNode(expr);
        }
    };
        
    // And
    //--------------------------------------------------------------------------
    class and_FunctionNode : public CFunctionNode
    {
    public:
        and_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() == 0.0 || m_nodes[1]->Evaluate() == 0.0)
                return 0.0;
            else
                return 1.0;
        }
    };
        
    class and_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "and";
        }
            
        FunctionNode *DoCreate(CExpression *expr)
        {
            return new and_FunctionNode(expr);
        }
    };
        
    // Or
    //--------------------------------------------------------------------------
    class or_FunctionNode : public CFunctionNode
    {
    public:
        or_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(2, 2, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() == 0.0 && m_nodes[1]->Evaluate() == 0.0)
                return 0.0;
            else
                return 1.0;
        }
    };
        
    class or_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "or";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new or_FunctionNode(expr);
        }
    };
        
    // Not
    //--------------------------------------------------------------------------
    class not_FunctionNode : public CFunctionNode
    {
    public:
        not_FunctionNode(CExpression *expr) : CFunctionNode(expr)
        {
            SetArgumentCount(1, 1, 0, 0);
        }
    
        double DoEvaluate()
        {
            if(m_nodes[0]->Evaluate() == 0.0)
                return 1.0;
            else
                return 0.0;
        }
    };
        
    class not_FunctionFactory : public CFunctionFactory
    {
    public:
        ::std::string GetName() const
        {
            return "not";
        }
            
        CFunctionNode *DoCreate(CExpression *expr)
        {
            return new not_FunctionNode(expr);
        }
    };

        
} // namespace


// Initialize default functions
void FunctionList::AddDefaultFunctions()
{
    #define ADDFUNCTION(name) \
        auto_ptr<CFunctionFactory> name ## _func(new name ## _FunctionFactory()); \
        m_functions.push_back(name ## _func.get()); \
        name ## _func.release();
    
    ADDFUNCTION(abs);
    ADDFUNCTION(mod);
    
    ADDFUNCTION(ipart);
    ADDFUNCTION(fpart);
    
    ADDFUNCTION(min);
    ADDFUNCTION(max);
    ADDFUNCTION(sqrt);
    
    ADDFUNCTION(sin);
    ADDFUNCTION(cos);
    ADDFUNCTION(tan);
    
    ADDFUNCTION(sinh);
    ADDFUNCTION(cosh);
    ADDFUNCTION(tanh);
    
    ADDFUNCTION(asin);
    ADDFUNCTION(acos);
    ADDFUNCTION(atan);
    ADDFUNCTION(atan2);
    
    ADDFUNCTION(log);
    ADDFUNCTION(ln);
    ADDFUNCTION(exp);
    ADDFUNCTION(logn);
    
    ADDFUNCTION(ceil);
    ADDFUNCTION(floor);
    
    ADDFUNCTION(rand);
    ADDFUNCTION(random);
    ADDFUNCTION(randomize);
    
    ADDFUNCTION(deg);
    ADDFUNCTION(rad);
    
    ADDFUNCTION(rect2pol);
    ADDFUNCTION(pol2rect);
    
    ADDFUNCTION(if); // Preprocess will take care of this beforehand
    ADDFUNCTION(select);
    
    ADDFUNCTION(equal)
    ADDFUNCTION(above);
    ADDFUNCTION(below);
    
    ADDFUNCTION(clip);
    ADDFUNCTION(clamp);
    ADDFUNCTION(rescale);
    
    ADDFUNCTION(poly);
    
    ADDFUNCTION(and);
    ADDFUNCTION(or);
    ADDFUNCTION(not);
}