Question

我正在尝试编写代码，以解决耦合的常微分方程（即ODE）。该功能需要接受一个功能数组，每个功能都是耦合的ODE之一。我正在尝试使用C ++ 17折叠表达式将函数传递给主函数，然后由主函数分别将函数一次传递给求解器。求解器需要求解方程，并根据结果修改输入图。该映射必须基于第一个函数的结果进行修改，因为修改后的映射是下一个函数的输入。通用代码如下所示。代码经过简化，以突出显示我要解决的问题。

int main()
{
    ODESolver q;
    std::map<std::string, double> inputs {
        {"x", 1.0},
        {"y", 2.0},
        {"z", 3.0},
        {"a", 4.0}
    };

    auto results = solver(inputs, func1, func2);
}

double func1(std::map<std::string, double> arr)
{
    double dcadt = -arr["x"] * arr["y"] + arr["z"] * arr["a"];
    return dcadt;
}

double func2(std::map<std::string, double> arr)
{
    double dccdt = arr["x"] * arr["y"] - arr["a"] * arr["z"];
    return dccdt;
}

班级信息显示在这里；

class ODESolver
{
public:
    template<typename ...Funcs>
    std::vector<double> framework(std::map<std::string, double> inputs, Funcs&&... funcs)
    {
        std::tuple<double, double> res;
        for (int i = 0; i < funcs.size(); i++)
        {
            // - THIS IS WHERE MY PROBLEM IS MANIFESTED, THE
            //   COMPILER WILL NOT LET ME EXTRACT AN INDIVIDUAL
            //   FUNCTION FROM A FOLD EXPRESSION!
            res = solver(inputs, funcs[i]);
            step_size = std::get<1>(res);
            inputs["x"] += 1.0;
            inputs["y"] std::get<0>(res);
        }
    }
    std::tuple<double, double>
    ODESolver::solver(std::map<std::string, double>, const std::function<double(std::map<std::string, double>)& func)
    {
        double dydt = func(inputs);
        double val = inputs["y"];
        std::tuple<double, double> values(dydt, val);
        return values;
    }
};

上面的示例有些虚构，但它突出了我的实际代码的问题。我不知道如何从C ++ 17折叠表达式中提取单个函数，因此我可以将它们分别传递给另一个函数。从上面的代码中可以看到，我需要首先解决func1，以便它可以在inputs在其函数调用中使用func2之前更新inputs映射。。是否可以使用fold表达式执行此操作，或者是否需要将函数从主程序传递给framework函数。

Answer 1

写一个lambda来做你需要做的事情：

auto apply_next = [&](auto&& f){
    res = solver(inputs, f);
    step_size = std::get<1>(res);
    inputs["x"] += 1.0;
    inputs["y"] += std::get<0>(res);
};

然后将lambda调用折叠为逗号：

(apply_next(funcs), ...);

Expansion Statements有望在C ++ 20上步入正轨，这将使您想要编写的更直接的内容从以下开始：

for ... (auto&& f : funcs) {
    res = solver(inputs, f);
    step_size = std::get<1>(res);
    inputs["x"] += 1.0;
    inputs["y"] += std::get<0>(res);
}

Answer 2

您不会使用常规的for循环遍历元组/可变模板。

您可以这样做：

template<typename ...Funcs>
std::tuple<double, double> framework(std::map<std::string, double> inputs, Funcs&&... funcs)
{
    std::tuple<double, double> res{};
    auto l = [&](const auto& func){
        res = solver(inputs, func);
        step_size = std::get<1>(res);
        inputs["x"] += 1.0;
        inputs["y"] std::get<0>(res);
    };
    (l(funcs), ...);

    return res;
}

我可以从C ++ 17折叠表达式中解析出各个函数吗

2 个答案: