functions.h

#ifndef AFL_FUNCTIONS_H
#define AFL_FUNCTIONS_H

#include "afltypes.h"

#include "basisinterpolator_1.h"
#include "basisinterpolator_2.h"
#include "basisinterpolator_3.h"
#include "basisinterpolator_4.h"

#include "functioniterator.h"

#include <string>

namespace afl
{
    class CompositeField;
    class Function
    {
        public:
            struct Context
            {
                Context(  );

                size_t row;

                size_t column;
            };

            virtual ~Function();
            virtual data_t evaluate( const Point& p, Context* ctxt = NULL ) const = 0;
            
            virtual void serialise( std::ostream& doc ) const = 0;

            virtual Function* clone(  ) const = 0;

            typedef FunctionIterator iterator;

            iterator begin(  ) { return iterator(this); }

            iterator end(  ) { return iterator(NULL); }

        private:
            friend class FunctionIterator;
            size_t getNumArgs(  ) const { return _args.size(); }

            Function* getArg( size_t argNum ) { return _args[argNum]; }

        protected:
            std::vector<Function*> _args;
    };
    
    class FieldFn : public Function
    {
        public:
            FieldFn( const Field* field, Function* arg );
            
            FieldFn( const Field* field, Function* arg1, Function* arg2 );

            FieldFn( const Field* field, Function* arg1, Function* arg2, Function* arg3 );
            
            FieldFn( const Field* field, Function* arg1, Function* arg2, Function* arg3, Function* arg4 );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;


        private:
            const Field* _f;
            size_t _row;
            size_t _col;
    };

    class Negate : public Function
    {
        public:
            Negate( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Argument : public Function
    {
        public:
            Argument( aspectid_t aspect );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private:
            aspectid_t _aspect;
            size_t _axis;
    };

    class BasisArgument : public Function
    {
        public:
            BasisArgument( size_t index );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const = 0;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const = 0;

        protected:
            size_t _u;
    };

    class BasisArgument_1 : public BasisArgument
    {
        public:
            BasisArgument_1( const BasisInterpolator_1* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_1;

            const BasisInterpolator_1* _interp;
    };

    class BasisArgument_2 : public BasisArgument
    {
        public:
            BasisArgument_2( const BasisInterpolator_2* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_2;

            const BasisInterpolator_2* _interp;
    };

    class BasisArgument_3 : public BasisArgument
    {
        public:
            BasisArgument_3( const BasisInterpolator_3* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_3;

            const BasisInterpolator_3* _interp;
    };

    class BasisArgument_4 : public BasisArgument
    {
        public:
            BasisArgument_4( const BasisInterpolator_4* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_4;

            const BasisInterpolator_4* _interp;
    };

    class KsiBasisArgument_1 : public BasisArgument
    {
        public:
            KsiBasisArgument_1( const BasisInterpolator_1* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_1;

            const BasisInterpolator_1* _interp;
    };

    class KsiBasisArgument_2 : public BasisArgument
    {
        public:
            KsiBasisArgument_2( const BasisInterpolator_2* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_2;

            const BasisInterpolator_2* _interp;
    };

    class KsiBasisArgument_3 : public BasisArgument
    {
        public:
            KsiBasisArgument_3( const BasisInterpolator_3* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_3;

            const BasisInterpolator_3* _interp;
    };

    class KsiBasisArgument_4 : public BasisArgument
    {
        public:
            KsiBasisArgument_4( const BasisInterpolator_4* interp, size_t index );
        
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private: 
            friend class BasisInterpolator_4;

            const BasisInterpolator_4* _interp;
    };

    class Constant : public Function
    {
        public:
            Constant( data_t val );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;

        private:
            data_t _val;
    };

    class Sum : public Function
    {
        public:
            Sum( Function* arg1, Function* arg2 );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Subtract : public Function
    {
        public:
            Subtract( Function* arg1, Function* arg2 );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Multiply : public Function
    {
        public:
            Multiply( Function* arg1, Function* arg2 );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Divide : public Function
    {
        public:
            Divide( Function* arg1, Function* arg2 );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Power : public Function
    {
        public:
            Power( Function* arg1, Function* arg2 );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class OnTopOf : public Function
    {
        public:
            OnTopOf( Function* arg1, Function* arg2 );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Sin : public Function
    {
        public:
            Sin( Function* arg );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };


    class ArcSin : public Function
    {
        public:
            ArcSin( Function* arg );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Cos : public Function
    {
        public:
            Cos( Function* arg );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class ArcCos : public Function
    {
        public:
            ArcCos( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Tan : public Function
    {
        public:
            Tan( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class ArcTan : public Function
    {
        public:
            ArcTan( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Cot : public Function
    {
        public:
            Cot( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Ln : public Function
    {
        public:
            Ln( Function* arg );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };
    
    class Exp : public Function
    {
        public:
            Exp( Function* arg );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    
    class Sqrt : public Function
    {
        public:
            Sqrt( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Abs : public Function
    {
        public:
            Abs( Function* arg );
            
            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Min : public Function
    {
        public:
            Min( Function* arg1, Function* arg2 );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    class Max : public Function
    {
        public:
            Max( Function* arg1, Function* arg2 );

            virtual data_t evaluate( const Point& p, Function::Context* ctxt ) const;
            
            virtual void serialise( std::ostream& doc ) const;

            virtual Function* clone(  ) const;
    };

    Function* parseFunction( const std::string& expression );

    Function* parseFunction( const std::string& expression, const CompositeField* cntxt );

    Function* parseFunction( const std::string& expression, const BasisInterpolator_1* cntxt );

    Function* parseFunction( const std::string& expression, const BasisInterpolator_2* cntxt );

    Function* parseFunction( const std::string& expression, const BasisInterpolator_3* cntxt );

    Function* parseFunction( const std::string& expression, const BasisInterpolator_4* cntxt );
}

#endif

---