[MaL] use std::function

MathLib/ODE/ConcreteOdeSolver.h

@@ -23,8 +23,8 @@
 
 namespace MathLib
 {
-template <unsigned NumEquations, typename... FunctionArguments>
-std::unique_ptr<OdeSolver<NumEquations, FunctionArguments...>> createOdeSolver(
+template <unsigned NumEquations>
+std::unique_ptr<OdeSolver<NumEquations>> createOdeSolver(
     BaseLib::ConfigTree const& config);
 
 /**
@@ -41,25 +41,21 @@ std::unique_ptr<OdeSolver<NumEquations, FunctionArguments...>> createOdeSolver(
  *
  * This way the \c Implementation does not need to be templated.
  */
-template <typename Implementation, unsigned NumEquations,
-          typename... FunctionArguments>
-class ConcreteOdeSolver final
-    : public OdeSolver<NumEquations, FunctionArguments...>,
-      private Implementation
+template <typename Implementation, unsigned NumEquations>
+class ConcreteOdeSolver final : public OdeSolver<NumEquations>,
+                                private Implementation
 {
 public:
-	using Interface = OdeSolver<NumEquations, FunctionArguments...>;
+	using Interface = OdeSolver<NumEquations>;
 	using Function = typename Interface::Function;
 	using JacobianFunction = typename Interface::JacobianFunction;
 
-	void setFunction(Function f, JacobianFunction df,
-	                 FunctionArguments&... args) override
+	void setFunction(Function f, JacobianFunction df) override
 	{
 		Implementation::setFunction(
-		    std::unique_ptr<
-		        detail::Handles<NumEquations, FunctionArguments...>>{
-		        new detail::Handles<NumEquations, FunctionArguments...>{
-		            f, df, args...}});
+		    std::unique_ptr<  // TODO unique_ptr not needed
+		        detail::Handles<NumEquations>>{
+		        new detail::Handles<NumEquations>{f, df}});
 	}
 
 	void setTolerance(const std::array<double, NumEquations>& abstol,
@@ -111,19 +107,17 @@ private:
 	{
 	}
 
-	friend std::unique_ptr<OdeSolver<NumEquations, FunctionArguments...>>
-	createOdeSolver<NumEquations, FunctionArguments...>(
-	    BaseLib::ConfigTree const& config);
+	friend std::unique_ptr<OdeSolver<NumEquations>>
+	createOdeSolver<NumEquations>(BaseLib::ConfigTree const& config);
 };
 
-template <unsigned NumEquations, typename... FunctionArguments>
-std::unique_ptr<OdeSolver<NumEquations, FunctionArguments...>> createOdeSolver(
+template <unsigned NumEquations>
+std::unique_ptr<OdeSolver<NumEquations>> createOdeSolver(
     BaseLib::ConfigTree const& config)
 {
 #ifdef CVODE_FOUND
-	return std::unique_ptr<OdeSolver<NumEquations, FunctionArguments...>>(
-	    new ConcreteOdeSolver<CVodeSolver, NumEquations, FunctionArguments...>(
-	        config));
+	return std::unique_ptr<OdeSolver<NumEquations>>(
+	    new ConcreteOdeSolver<CVodeSolver, NumEquations>(config));
 #else
 	return nullptr;
 #endif  // CVODE_FOUND

MathLib/ODE/Handles.h

@@ -10,61 +10,15 @@
 #ifndef MATHLIB_ODE_HANDLES_H
 #define MATHLIB_ODE_HANDLES_H
 
+#include "OdeSolverTypes.h"
+
 namespace MathLib
 {
 namespace detail
 {
-/// Function handles for N equations and arbitrary arguments.
-template <unsigned N, typename... FunctionArguments>
-struct Handles;
-
-/// Function handles for N equations and single argument.
-template <unsigned N, typename FunctionArgument>
-struct Handles<N, FunctionArgument> : public MathLib::FunctionHandles
-{
-	using Function = MathLib::Function<N, FunctionArgument>;
-	using JacobianFunction = MathLib::JacobianFunction<N, FunctionArgument>;
-
-	Handles(Function& f, JacobianFunction& df, FunctionArgument& arg)
-	    : f(f), df(df), _data(arg)
-	{
-	}
-
-	bool call(const double t, const double* const y,
-	          double* const ydot) override
-	{
-		// looks like f and df could be any callable object with suitable
-		// signature
-		// consider omission of data pointer and switch to std::function or
-		// alike
-		if (f)
-			return f(t, MappedConstVector<N>{y}, MappedVector<N>{ydot}, _data);
-		return true;
-	}
-
-	bool callJacobian(const double t, const double* const y, double* const ydot,
-	                  double* const jac) override
-	{
-		if (df)
-			return df(t,
-			          MappedConstVector<N>{y},
-			          MappedVector<N>{ydot},
-			          MappedMatrix<N, N>{jac},
-			          _data);
-		return true;
-	}
-
-	bool hasJacobian() const override { return df != nullptr; }
-	unsigned getNumEquations() const override { return N; }
-private:
-	Function f = nullptr;
-	JacobianFunction df = nullptr;
-	FunctionArgument& _data;
-};
-
-/// Function handles for N equations and no arguments.
+/// Function handles for N equations.
 template <unsigned N>
-struct Handles<N> : public MathLib::FunctionHandles
+struct Handles : public MathLib::FunctionHandles
 {
 	using Function = MathLib::Function<N>;
 	using JacobianFunction = MathLib::JacobianFunction<N>;
@@ -73,11 +27,8 @@ struct Handles<N> : public MathLib::FunctionHandles
 	bool call(const double t, const double* const y,
 	          double* const ydot) override
 	{
-		if (f)
-		{
-			return f(t, MappedConstVector<N>{y}, MappedVector<N>{ydot});
-		}
-		return true;
+		if (f) return f(t, MappedConstVector<N>{y}, MappedVector<N>{ydot});
+		return false;
 	}
 
 	bool callJacobian(const double t, const double* const y, double* const ydot,
@@ -86,15 +37,15 @@ struct Handles<N> : public MathLib::FunctionHandles
 		if (df)
 			return df(t,
 			          MappedConstVector<N>{y},
-			          MappedVector<N>{ydot},
+			          MappedConstVector<N>{ydot},
 			          MappedMatrix<N, N>{jac});
-		return true;
+		return false;
 	}
 
 	bool hasJacobian() const override { return df != nullptr; }
 	unsigned getNumEquations() const override { return N; }
-	Function f = nullptr;
-	JacobianFunction df = nullptr;
+	Function f;
+	JacobianFunction df;
 };
 
 }  // namespace detail

MathLib/ODE/OdeSolver.h

@@ -23,16 +23,14 @@ namespace MathLib
  * It provides type-safe and array-bounds checked access to external
  * ODE solver libraries. However, it is agnostic to the specific solver used.
  */
-template <unsigned NumEquations, typename... FunctionArguments>
+template <unsigned NumEquations>
 class OdeSolver
 {
 public:
-	using Function = MathLib::Function<NumEquations, FunctionArguments...>;
-	using JacobianFunction =
-	    MathLib::JacobianFunction<NumEquations, FunctionArguments...>;
+	using Function = MathLib::Function<NumEquations>;
+	using JacobianFunction = MathLib::JacobianFunction<NumEquations>;
 
-	virtual void setFunction(Function f, JacobianFunction df,
-	                         FunctionArguments&... args) = 0;
+	virtual void setFunction(Function f, JacobianFunction df) = 0;
 
 	virtual void setTolerance(const std::array<double, NumEquations>& abstol,
 	                          const double reltol) = 0;

MathLib/ODE/OdeSolverTypes.h

@@ -10,6 +10,7 @@
 #ifndef MATHLIB_ODE_ODESOLVERTYPES_H
 #define MATHLIB_ODE_ODESOLVERTYPES_H
 
+#include <functional>
 #include <Eigen/Core>
 
 namespace MathLib
@@ -27,18 +28,15 @@ using MappedVector = MappedMatrix<N, 1>;
 template <int N>
 using MappedConstVector = MappedConstMatrix<N, 1>;
 
-template <unsigned N, typename... FunctionArguments>
-using Function = bool (*)(const double t,
-                          MappedConstVector<N> const y,
-                          MappedVector<N> ydot,
-                          FunctionArguments&... arg);
-
-template <unsigned N, typename... FunctionArguments>
-using JacobianFunction = bool (*)(const double t,
-                                  MappedConstVector<N> const y,
-                                  MappedVector<N> ydot,
-                                  MappedMatrix<N, N> jac,
-                                  FunctionArguments&... arg);
+template <unsigned N>
+using Function = std::function<bool(
+    const double t, MappedConstVector<N> const y, MappedVector<N> ydot)>;
+
+template <unsigned N>
+using JacobianFunction = std::function<bool(const double t,
+                                            MappedConstVector<N> const y,
+                                            MappedConstVector<N> ydot,
+                                            MappedMatrix<N, N> jac)>;
 
 // This is an internal detail
 class FunctionHandles