Previous iteration-memoization with CRTP-interfaces - c++

Question

I have a Curiously Recurring Template Pattern (CRTP) interface-class where I want to memoize evaluations for all methods defined by the derived classes. I also have return values whose types are template-defined. Example:
template <class Derived, class Ret1, class Ret2>
class memoization_class
{
int operator_iter, Eval_1_iter, Eval_2_iter;
double data_operator;
Ret1 data_Eval_1;
Ret2 data_Eval_2;
public:
//Desired memoization:
double operator()(const double &arg, const int& iter)
{
if (iter != operator_iter)
{
data_operator = static_cast<Derived *>(this)->operator(arg);
operator_iter = iter;
return data_operator;
}
else
{
return data_operator;
}
}
//Want to create the same buffer for an arbitrary return type, for an arbitrary amount of methods
Ret1 Eval_1(const double &arg, const int& iter)
{
return static_cast<Derived *>(this)->Eval_1(arg);
}
Ret2 Eval_2(const double &arg, const int& iter)
{
return static_cast<Derived *>(this)->Eval_2(arg);
}
};
Is it possible to generalize this behaviour to something like this:
template <class Derived, class Ret1, class Ret2>
class memoization_class
{
int operator_iter, Eval_1_iter, Eval_2_iter;
double data_operator;
Ret1 data_Eval_1;
Ret2 data_Eval_2;
public:
double operator()(const double &arg, const int& iter)
{
return memoize(&static_cast<Derived *>(this)->operator(), arg, iter);
}
//..
};
Edit: Here is the application for the problem. It uses Eigen, and may return Sparse or Dense matrices/vectors. (The class provides functions for optimizing nonlinear problems)
MatrixBase is in this case a substitute for Vec in order to allow Eigen to pass all kinds of unevaluated expressions.
#ifndef OBJECTIVE_HPP
#define OBJECTIVE_HPP
#include "EigenDataTypes.hpp"
// template <class Base, class Mat>
// using is_Base = std::enable_if_t<std::is_base_of<Base, Mat>::value>;
// template <class Derived, class Vec, class Mat, typename Enable = void>
// struct objective;
template <class Derived, class Vec, class Mat>
struct objective
{
protected:
int Nx_, nnzh_;
public:
objective(const int &Nx, const int &nnzh) : Nx_(Nx), nnzh_(nnzh) {}
template <typename T>
inline scalar operator()(const MatrixBase<T> &x)
{
return static_cast<Derived *>(this)->operator()(x);
}
template <typename T>
inline Vec Eval_grad(const MatrixBase<T> &x)
{
return static_cast<Derived *>(this)->Eval_grad(x);
}
template <typename T>
inline Mat Eval_hessian(const MatrixBase<T> &x)
{
return static_cast<Derived *>(this)->Eval_hessian(x);
}
template <typename T>
inline scalar operator()(const SparseMatrixBase<T> &x)
{
return static_cast<Derived *>(this)->operator()(x);
}
template <typename T>
inline Vec Eval_grad(const SparseMatrixBase<T> &x)
{
return static_cast<Derived *>(this)->Eval_grad(x);
}
template <typename T>
inline Mat Eval_hessian(const SparseMatrixBase<T> &x)
{
return static_cast<Derived *>(this)->Eval_hessian(x);
}
inline int Get_Nx()
{
return Nx_;
}
inline int Get_nnzh()
{
return nnzh_;
}
};
EigenDataTypes.hpp:
#ifndef EIGENDATATYPES_H
#define EIGENDATATYPES_H
#include <Eigen/Dense>
#include <Eigen/Sparse>
using scalar = Eigen::Matrix<double, 1, 1>;
using Eigen::MatrixXd;
using Eigen::VectorXd;
using spVec = Eigen::SparseVector<double>;
using spMat = Eigen::SparseMatrix<double>;
using dVec = Eigen::VectorXd;
using dMat = Eigen::MatrixXd;
using Eigen::MatrixBase;
using Eigen::SparseMatrixBase;
using Triplet = Eigen::Triplet<double>;
#endif
Edit 2: Here is my rather verbose implementation of memoization for the objective-class. (It checks for change in input x instead of iteration-change):
template <class Data>
struct memData
{
dVec x;
Data data;
memData(const int &Nx) : x(Nx)
{
}
};
inline bool
is_memoized(const dVec &x, const dVec &x_mem)
{
return ((x - x_mem).array().abs() <= std::numeric_limits<double>::epsilon()).all();
}
template <class Derived, class Vec, class Mat>
struct objective_memoized : public objective<objective_memoized<Derived, Vec, Mat>, Vec, Mat>
{
protected:
int &Nx_ = objective<objective_memoized<Derived, Vec, Mat>, Vec, Mat>::Nx_;
int &nnzh_ = objective<objective_memoized<Derived, Vec, Mat>, Vec, Mat>::nnzh_;
memData<scalar> mem_operator;
memData<Vec> mem_Eval_grad;
memData<Mat> mem_Eval_hessian;
public:
objective_memoized(const int &Nx, const int &nnzh) : objective<objective_memoized<Derived, Vec, Mat>, Vec, Mat>(Nx, nnzh),
mem_operator(Nx),
mem_Eval_grad(Nx),
mem_Eval_hessian(Nx)
{
}
objective_memoized(const int &Nx, const int &Ns, const int &nnzh) : objective<objective_memoized<Derived, Vec, Mat>, Vec, Mat>(Nx, nnzh),
mem_operator(Nx + Ns),
mem_Eval_grad(Nx + Ns),
mem_Eval_hessian(Nx + Ns)
{
}
template <typename T>
inline scalar operator()(const MatrixBase<T> &x)
{
if (!is_memoized(x, mem_operator.x))
{
mem_operator.data = static_cast<Derived *>(this)->operator()(x);
mem_operator.x = x;
}
return mem_operator.data;
}
template <typename T>
inline Vec Eval_grad(const MatrixBase<T> &x)
{
if (!is_memoized(x, mem_Eval_grad.x))
{
mem_Eval_grad.data = static_cast<Derived *>(this)->Eval_grad(x);
mem_Eval_grad.x = x;
}
return mem_Eval_grad.data;
}
template <typename T>
inline Mat Eval_hessian(const MatrixBase<T> &x)
{
if (!is_memoized(x, mem_Eval_hessian.x))
{
mem_Eval_hessian.data = static_cast<Derived *>(this)->Eval_hessian(x);
mem_Eval_hessian.x = x;
}
return mem_Eval_hessian.data;
}
template <typename T>
inline scalar operator()(const SparseMatrixBase<T> &x)
{
if (!is_memoized(x, mem_operator.x))
{
mem_operator.data = static_cast<Derived *>(this)->operator()(x);
mem_operator.x = x;
}
return mem_operator.data;
}
template <typename T>
inline Vec Eval_grad(const SparseMatrixBase<T> &x)
{
if (!is_memoized(x, mem_Eval_grad.x))
{
mem_Eval_grad.data = static_cast<Derived *>(this)->Eval_grad(x);
mem_Eval_grad.x = x;
}
return mem_Eval_grad.data;
}
template <typename T>
inline Mat Eval_hessian(const SparseMatrixBase<T> &x)
{
if (!is_memoized(x, mem_Eval_hessian.x))
{
mem_Eval_hessian.data = static_cast<Derived *>(this)->Eval_hessian(x);
mem_Eval_hessian.x = x;
}
return mem_Eval_hessian.data;
}
};
TLDR; I want to return stored data if it has been evaluated previously this iteration, or evaluate, store & return if not. Can I use one function to define this for all return types?