Question

I would like to implement real functions in C++. In particular I would like to evaluate, differentiate, add, multiply such objects. Here is my implementation

class RealFunc {
public:
    virtual int Eval(const double& x, double& result) = 0;
    virtual int Diff(const double& x, double& result) = 0;
};

class Sqrt : public RealFunc {
public:
    int Eval(const double& x, double& result);
    int Diff(const double& x, double& result); 
};

int Sqrt::Eval(const double& x, double& result) {
    if(x<0) return 0;
    else {
        result = sqrt(x);
        return 1;
    }
};

int Sqrt::Diff(const double& x, double& result) {
    if(x<=0) return 0;
    else {
        result = 0.5/sqrt(x);
        return 1;
    }
};

It gets tricky when I try to add RealFunc objects. I have to create a sum class that inherits from RealFunc

RealFunc operator+(const RealFunc& f, const RealFunc& g) {
    Sum_RealFunc h(f,g);
    return h;
};

class Sum_RealFunc : public RealFunc {
public:
    Sum_RealFunc(const RealFunc& f_, const RealFunc& g_) : f(f_), g(g_) {};
    int Eval(const double& x, double& result);
    int Diff(const double& x, double& result);
private:
    RealFunc f;
    RealFunc g;
};

int Sum_RealFunc::Eval(const double& x, double& result) {
    double temp_f,temp_g;
    int success_f,success_g;
    success_f = f.Eval(x,temp_f);
    success_g = g.Eval(x,temp_g);
    result = temp_f+temp_g;
    return success_f*success_g;
};

// Same for Sum_RealFunc::Diff

My issue here is that I cannot use f,g as members in Sum_RealFunc since RealFunc is abstract… How should I proceed to get a clean implementation ?

PS : The code I put is a light version of what I am working on (functions from RxR->R with all differentiation directions, finite difference if stepsize member is not zero and other side functions)

Answer 1

Try

class Sum_RealFunc : public RealFunc {
    public:
        Sum_RealFunc(RealFunc& f_, RealFunc& g_) : f(f_), g(g_) {};
        int Eval(const double& x, double& result);
        int Diff(const double& x, double& result);
    private:
        RealFunc& f;
        RealFunc& g;
};

Now f and g are refernces instead which is fine.