Functions.h

Go to the documentation of this file.

#ifndef __FUNCTIONS_H
#define __FUNCTIONS_H

#include "../Core/SharedLibraryExportMacros.h"
#include "Common.h"
#include "Error.h"
//#include <solve_polynomial.h>
#include <cmath>
#include <limits>
#include <valarray>
#include <list>
#include <iterator>
#include <iostream>

#ifndef NO_SERIALIZE
    #include <boost/serialization/base_object.hpp>
    #include <boost/archive/text_oarchive.hpp>
    #include <boost/archive/text_iarchive.hpp>
    #include <boost/serialization/export.hpp>
#endif

namespace Core {

    class InterpSolutionIterator;

    template<class InputDataType, class OutputDataType>
        class LIB_LOCAL OneArgumentFunction {
#ifndef NO_SERIALIZE
            friend class boost::serialization::access;

            template<class Archive>
                void serialize(Archive &, const unsigned int) {}
#endif
        public:
            virtual OutputDataType operator()(
                InputDataType in_value
            ) const =0;

            virtual InputDataType range_high() const=0;

            virtual InputDataType range_low() const=0;

            virtual InterpSolutionIterator crossings(double y=0) const =0;

            virtual ~OneArgumentFunction() {};
        };

    class LIB_LOCAL FunctionDerivatives {
    public:
        virtual double order(unsigned deriv_order=1) const =0;

        virtual ~FunctionDerivatives() {};
    };

    class LIB_LOCAL CubicSplineDerivatives : public FunctionDerivatives {
    private:
        double zeroth, 
               first, 
               second; 
    public:
        CubicSplineDerivatives(
            double func_value,

            double first_deriv, 

            double second_deriv);

        double order(unsigned deriv_order=1) const;
    };

    class LIB_LOCAL OneArgumentDiffFunction 
        : public OneArgumentFunction<double,double> {
    private :
#ifndef NO_SERIALIZE
        friend class boost::serialization::access;

        template<class Archive>
            void serialize(Archive & ar, const unsigned int) {
                ar & boost::serialization::base_object< 
                        OneArgumentFunction<double,double> 
                     >(*this);
            }
#endif
    public:
        virtual const FunctionDerivatives *deriv(double x) const=0;

        virtual ~OneArgumentDiffFunction() {}
    };

    class LIB_LOCAL ZeroDerivatives : public FunctionDerivatives {
    public:
        ZeroDerivatives() {}

        double order(unsigned =1) const {return 0;}
    };

    class LIB_LOCAL ZeroFunction : public OneArgumentDiffFunction {
    private :
#ifndef NO_SERIALIZE
        friend class boost::serialization::access;

        template<class Archive>
            void serialize(Archive & ar, const unsigned int) {
                ar & boost::serialization::base_object< OneArgumentDiffFunction >(
                    *this
                );
            }
#endif

    public:
        virtual const FunctionDerivatives *deriv(double) const
        {return new ZeroDerivatives;}

        double operator()(double) const {return 0;}

        double range_high() const {return Inf;}

        double range_low() const {return -Inf;}

        InterpSolutionIterator crossings(double =0) const;
    };
   
} //End Core namespace.

#endif