funcs_base.hpp

#ifndef FUNC_BASE_HEADER_INPU
#define FUNC_BASE_HEADER_INPU

#include "input_file.hpp"
#include <vector>
#include <complex>

typedef std::complex<double> complex;

class function_Object: public loadable_Object{
public:
    typedef STD_TR1::shared_ptr<       function_Object>       ref;
    typedef STD_TR1::shared_ptr< const function_Object> const_ref;

    virtual ~function_Object() throw() {};

    double operator()(const double d) const 
    { 
        return value((d-x0)/range_) * scale_ + y0;
    };
      
    double x_min() const { return x0;};
    double x_max() const { return x0 + range_;};

    double y_min() const { return y0;};
    double y_max() const { return y0 + scale_;};

    double range() const { return range_;};
    double scale() const { return scale_;};

private:
    double range_;
    double scale_;
    double x0;
    double y0;

    void init();

    virtual void init_func() = 0;    
    virtual double value(const double d) const = 0;
};

class function_complex_Object: public loadable_Object{
public:
    typedef STD_TR1::shared_ptr<       function_complex_Object>       ref;
    typedef STD_TR1::shared_ptr< const function_complex_Object> const_ref;

    virtual ~function_complex_Object() throw() {};

    complex operator()(const double d) const 
    { 
        return value((d-x0)/range_) * scale_ + y0;
    };
      
    double x_min() const { return x0;};
    double x_max() const { return x0 + range_;};

    double y_min() const { return y0;};
    double y_max() const { return y0 + scale_;};

    double range() const { return range_;};
    double scale() const { return scale_;};

private:
    double range_;
    double scale_;
    double x0;
    double y0;

    void init(); 

    virtual void init_func() = 0;    
    virtual complex value(const double d) const = 0;
};

/*
function2d_Object is an abstract base class for functions with two continuous parameters (i.e. f(x1,x2)).
Contrary to function_Object, no scaling features are implemented here; I suggest to define them in the derived classes if needed (see gaussian2d_func).
*/
class function2d_Object: public loadable_Object {
public:
    typedef STD_TR1::shared_ptr<       function2d_Object>       ref;
    typedef STD_TR1::shared_ptr< const function2d_Object> const_ref;

    function2d_Object(): start_x1_(0), start_x2_(0){};

    ~function2d_Object() throw() {};

    double operator()(const double x1,const double x2) const 
    { 
        return value(x1 - start_x1_,x2 - start_x2_);
    };

      

private:
    double start_x1_;
    double start_x2_;

    void init(); 

    virtual void init_func() = 0;    
    virtual double value(const double x1,const double x2) const = 0;

};

class function_complex2d_Object: public loadable_Object {
public:
    typedef STD_TR1::shared_ptr<       function_complex2d_Object>       ref;
    typedef STD_TR1::shared_ptr< const function_complex2d_Object> const_ref;

    function_complex2d_Object() :start_x1_(0), start_x2_(0) {};
    virtual ~function_complex2d_Object() throw() {};

    complex operator()(const double x1,const double x2) const 
    { 
        return value(x1-start_x1_,x2-start_x2_);
    };

      

private:
    double start_x1_;
    double start_x2_;

    void init();

    virtual void init_func()  = 0;    
    virtual complex value(const double x1,const double x2) const = 0;

};



class vector_Object: public loadable_Object{
public:
    typedef STD_TR1::shared_ptr<       vector_Object>       ref;
    typedef STD_TR1::shared_ptr< const vector_Object> const_ref;

    virtual ~vector_Object() throw() {};

    double operator[](const size_t i) const { 
//        if (i >= size()) throw (E_bad_index(i));
    do_lazy_init();
        return data[i % data.size()];
    };    

    size_t size() const { return data.size();};

    void output(std::ostream&) const;

    const std::vector<double>& provide_vector() const { return data;};

    void set_complex_vector_real(std::vector<complex>&) const;
    void set_complex_vector_imag(std::vector<complex>&) const;

protected:
    void set_element(const size_t i, double d) const{
        if (i >= data.size()) throw (E_bad_index(i));
        data[i] = d;
    }

    mutable bool lazy_initialized;
private:
    mutable std::vector<double> data;

    void init(); 
    void init_from_clone( loadable_Object::const_ref );

    void do_lazy_init() const{ if (!lazy_initialized){ lazy_initialized = true; lazy_init();}};

    virtual void init_vector() = 0;
    virtual void lazy_init() const;
    virtual size_t determine_size();
};


class Enumeration_vector_Object: public vector_Object{
public:
    ~Enumeration_vector_Object() throw() {};
private:
    STD_TR1::shared_ptr<std::vector<double> > enum_data;

    virtual size_t determine_size();
    const char* name() const {return "Enumeration_vector";};
    void init_vector();
};


class vector_function_Object: public vector_Object{
public:
    ~vector_function_Object() throw() {};
private:
    const char* name() const {return "vector_function";};

    void init_vector();
};

#endif