Integrator1D.h

#ifndef gridripper_math_Integrator1D
#define gridripper_math_Integrator1D

#include <gridripper/config.h>
#include <gridripper/lang/IllegalArgumentException.h>
#include <string>

namespace gridripper { namespace math {

using namespace std;


class IntegratorIncremental1D
{
    protected:
        int n;
        GReal_t integral;
        IntegratorIncremental1D() : n(0), integral(0.0) {  }
        IntegratorIncremental1D(const IntegratorIncremental1D& other)
         : n(other.n), integral(other.integral) {  }
    public:
        virtual ~IntegratorIncremental1D() {  }
        virtual void reset() = 0;
        virtual void increment(GReal_t x, GReal_t f) = 0;
        virtual GReal_t integrate() const throw(IllegalArgumentException&) = 0;
        virtual string toString() const = 0;
        int getN() const { return n; }
        virtual IntegratorIncremental1D* cloneIntegrator() const =0;
};


class TrapesoidalIntegratorIncremental1D : public IntegratorIncremental1D
{
    private:
        GReal_t xprev;
        GReal_t fprev;
    public:
        TrapesoidalIntegratorIncremental1D();
        TrapesoidalIntegratorIncremental1D(const TrapesoidalIntegratorIncremental1D&);
        void reset();
        void increment(const GReal_t x, const GReal_t f);
        GReal_t integrate() const throw(IllegalArgumentException&);
        string toString() const { return "TrapesoidalIntegratorIncremental1D"; }
        virtual IntegratorIncremental1D* cloneIntegrator() const {
            return new TrapesoidalIntegratorIncremental1D(*this);
        }
};


class SimpsonIntegratorIncremental1D : public IntegratorIncremental1D
{
    private:
        GReal_t xprevprev;
        GReal_t fprevprev;
        GReal_t xprev;
        GReal_t fprev;
    public:
        SimpsonIntegratorIncremental1D();
        SimpsonIntegratorIncremental1D(const SimpsonIntegratorIncremental1D&);
        void reset();
        void increment(GReal_t x, GReal_t f);
        GReal_t integrate() const throw(IllegalArgumentException&);
        string toString() const { return "SimpsonIntegratorIncremental1D"; }
        virtual IntegratorIncremental1D* cloneIntegrator() const {
            return new SimpsonIntegratorIncremental1D(*this);
        }
};


class Integrator1D
{
    protected:
        Integrator1D() {  }

        Integrator1D(const Integrator1D&) {  }

    public:

        virtual ~Integrator1D() {  }

        virtual GReal_t integrate(const GReal_t* x, const GReal_t* f, 
        int start, int n) const throw(IllegalArgumentException&) = 0;

        virtual string toString() const = 0;
};


class TrapesoidalIntegrator1D: public Integrator1D
{
    public:
        TrapesoidalIntegrator1D() : Integrator1D() {  }

        TrapesoidalIntegrator1D(const TrapesoidalIntegrator1D& other)
         : Integrator1D(other) {  }

        ~TrapesoidalIntegrator1D() {  }

        GReal_t integrate(const GReal_t* x, const GReal_t* f, int start, int n)
        const throw(IllegalArgumentException&);

        string toString() const { return "TrapesoidalIntegrator1D"; }
};


class SimpsonIntegrator1D: public Integrator1D
{
    public:
        SimpsonIntegrator1D() : Integrator1D() {  }

        SimpsonIntegrator1D(const SimpsonIntegrator1D& other)
         : Integrator1D(other) {  }

        ~SimpsonIntegrator1D() {  }

        GReal_t integrate(const GReal_t* x, const GReal_t* f, int start, int n)
        const throw(IllegalArgumentException&);

        string toString() const { return "SimpsonIntegrator1D"; }
};


} } // namespace gridripper::math

#endif /* gridripper_math_Integrator1D */