Create a function in the memory to call it later - c++

Question

Ok, my question is probably stupid, but I will regreat not asking it.
I would like to know if it is possible to create a function during program execution and then be able to call it later. This function will not be hard coded because it depends on many initial parameters decided by the program user. The objective would be to avoid calling these parameters, each time we need to call this function and hence, gain execution time and memory. I will give a minimalist example because I believe my question is not so easy to understand just with words.
In this example, I have a class Parameters that contain parameters A1, A2, A3 used to solve an equation. These parameters vary due to initial conditions. The second class CalculFunction uses these Parameters to solve the equation at the moment t. The way it is coded, each time I have to evaluate a new moment t', I have to go through the Parameters objects again to solve the equation. However, I would like to store directly a function in the memory, that contains the correct parameters and can be evaluated at t1, t2 etc.. without requiring to call startCalculation(const double & t, const double & initValue) method again.
My goal is to construct the function only one time and have in the memory a function f[i] = initValue * sum( A1[i][j] / A2[i][j] * exp( -A3[i] * t) where the sum occurs on j. Hence, I just call fi to get results without reconstructing the whole loops on j.
class Parameters
{
public:
Parameters();
QVector<double> & getA1(){return m_a1;};
QVector<double> & getA2(){return m_a2;};
double & getA3(){return m_a3;};
private:
QVector<double> m_a1;
QVector<double> m_a2;
double m_a3;
};
class CalculFunction
{
public:
CalculFunction(const QVector<Parameters> & allParam): m_parameters(allParam);
void startCalculation(const double & t, const double & initValue)
{
for(int i = 0; i < m_parameters.size(); i++)
{
m_results.append(0.);
for(int j = 0; j < m_parameters[i].getA1().size(); j++)
{
m_results[i] += m_parameters[i].getA1()[j] / m_parameters[i].getA2()[j] * exp(- (m_parameters[i].getA3() ) * t );
}
m_results[i] *= initValue;
}
}
private:
QVector<Parameters> m_parameters;
QVector<double> m_results;
};

Answer 1

You are looking for functor then. Functor is a class that is capable to storing internal states but has the operator() member that acts like a function.
class AFunc
{
public:
AFunc(A1 a1, A2 a2, A3 a3) : a1(a1), a2(a2), a3(a3) {}
T operator()(arguments ...) {
T t
...
return t;
}
private:
A1 a1;
A2 a2;
A3 a3;
};
where T is the return type.
You can have as many arguments in the constructor and operator(...) as you need.
You would just call it like
AFunc af(a1, a2, a3);
T t = af(arguments ...);
in your code.

Answer 2

I would re-envision your Parameters class. At the moment, it is a glorified struct, some data with getters, but no logic. Instead of simply storing the parameters, you could view it as your function. Put the logic of how to calculate a value at a particular time in this class. If you want it to look like a function call, you can use operator(), but you could also use a named member function, perhaps eval(). Let's go with the operator for now.
class Function // Not the best name, but good enough for now.
{
public:
Function(QVector<double> param1, QVector<double> param2, double param3) :
m_a1(std::move(param1)),
m_a2(std::move(param2)),
m_a3(param3)
{}
// This is what will evaluate your function at a given time. This will not
// speed up the execution, but it does help improve data encapsulation.
double operator()(double t)
{
double result = 0.0;
for(int j = 0; j < m_a1.size(); j++)
{
result += m_a1[j] / m_a2()[j] * exp(- m_a3 * t );
}
return result;
}
private:
const QVector<double> m_a1; // Add `const` to these if you want to
const QVector<double> m_a2; // emphasize that they do not change
const double m_a3; // after initialization.
};
All that's happened is some logic got shifted into this class. There is no expected savings in execution time. The savings comes when you try to write your other class.
class CalculFunction
{
public:
CalculFunction(const QVector<Function> & allParam): m_parameters(allParam) {}
void startCalculation(const double & t, const double & initValue)
{
for(int i = 0; i < m_parameters.size(); i++)
m_results.append(m_parameters[i](t) * initValue); // Invoke operator() here
}
private:
QVector<Function> m_parameters;
QVector<double> m_results;
};
The overall code is shorter and more organized, optimizing the programmer's time.