参数向量类型未知的虚函数

Question

我正试图在C++中构建一个用于参数优化的优化库。

问题和参数类型可能会有所不同，例如，如果问题是最小化阿克利函数，那么我们就有一个大小为2的vector<double> ( x为索引0，y为索引1)。然而，当参数是整数，甚至是字符串时，我们可能会遇到问题。

这类优化有很多算法，如遗传算法、差分进化等。在大多数算法中，一旦我们根据参数的优化策略对参数进行修改，就必须调用一个接收参数的评价函数，并给出一个目标函数，然后返回一个值(适应度)。

我的问题是如何在Problem中实现抽象类C++，以便它包含一个virtual double evaluate函数，其中接收相关问题的泛型类型的向量作为参考？例如，用户的问题应该继承Problem，他需要指定一个类型的T，在这种情况下，评估函数应该类似于virtual double evaluate(const vector<T> &parameters){}。

如果我上面提到的策略对C++不可行。请提出替代策略。

Answer 1

基于@Quentin注释和您的详细信息，首先可以将问题声明为类模板

#include <vector>
#include <typeinfo>
#include <iostream>

using namespace std;

template<class T>
class Problem
{
public:
    Problem() {
        if(typeid(T) == typeid(double)){
            cout << "The problem is of type double" << endl;
        }
    }

    virtual double evaluate(const vector<T> &decisionVariables) = 0;
};

然后，您可以继承它，并根据您的需要重写评估函数。由于您提到了Ackley函数，我实现了一个AckleyFunction，它继承了类型为double的问题。

#include "problem.h"
#include "math.h"

using namespace std;

class AckleyFunction : public Problem<double>
{
public:
    AckleyFunction() {}

    double evaluate(const vector<double> &decisionVariables) override {
        const double x = decisionVariables[0];
        const double y = decisionVariables[1];
        return -20 * exp(-0.2 * sqrt(0.5 * (pow(x, 2) + pow(y, 2)))) - exp(0.5 * (cos(2 * M_PI * x) + cos(2 * M_PI * y))) + exp(1) + 20;
    }
};

Ackley函数的全局最小值为x= 0，y= 0。你可以在main.cpp中看到这个低沉的声音

#include <ackleyfunction.h>
#include <memory>

using namespace std;

int main(int argc, char *argv[])
{
    shared_ptr<Problem<double>> prob(new AckleyFunction());
    vector<double> decisionVariables = {5.1, 3.3};
    cout << "Value at coordinates (5.1, 3.3): " << prob->evaluate(decisionVariables) << endl;

    decisionVariables = {0., 0.};
    cout << "Value at coordinates (0.0, 0.0): "  << prob->evaluate(decisionVariables) << endl;
}

输出：

The problem is of type double
Value at coordinates (5.1, 3.3): 12.9631
Value at coordinates (0.0, 0.0): 0

Answer 2

像这样的东西会起作用吗？

#include <memory>
#include <iostream>
#include <vector>

class Problem {
public:
    virtual double evaluate() = 0;
};

class MyProblem : public Problem {
public:
    MyProblem(const std::vector<float>& parameters) : mParameters(parameters) {}
    double evaluate() override {
        // Do evaluation based on mParameters
        return 47.11;
    }

private:
    const std::vector<float>& mParameters;
};


int main() {
    std::vector<float> v = {1.0f, 2.0f};

    std::unique_ptr<Problem> p{new MyProblem(v)};
    std::cout << p->evaluate() << '\n';  // Calls MyProblem::evaluate()

    return 0;
}