C++中如何优化方程参数替换以提升计算速度？

我有一组接收向量输入、输出不同时间步解的方程。方程中部分参数在运行时获取，且在当前周期内保持恒定。我希望将这类参数替换为运行时计算得到的值，使后续计算使用已替换参数的方程。实际问题包含4000个此类参数，以下为示例说明：

示例原方程：

rval[0]  = -p1*x + p2*y*z;
rval[1]  = -rval[0] - p3*y*y - dy;
rval[0] -=  dx;
rval[2]  =  x + y + z - 1;

{p1,p2,p3}为运行时获取的固定参数，替换后的方程如下：

替换后方程：

rval[0]  = (-0.04)*x + (1.0e4)*y*z;
rval[1]  = -rval[0] - (3.0e7)*y*y - dy;
rval[0] -=  dx;
rval[2]  =  x + y + z - 1;

我曾尝试使用SymEngine符号C++库，但参数替换和方程计算存在额外开销，相关代码如下：

// Create a map for substitution
SymEngine::map_basic_basic subs_map;
subs_map[x_sym] = real_double(x);
subs_map[y_sym] = real_double(y);
subs_map[z_sym] = real_double(z);
subs_map[dx_sym] = real_double(dx);
subs_map[dy_sym] = real_double(dy);
subs_map[dz_sym] = real_double(dz);

// Evaluate equations
rval[0] = SymEngine::eval_double(*resv1->subs(subs_map));
rval[1] = SymEngine::eval_double(*resv2->subs(subs_map));
rval[2] = SymEngine::eval_double(*resv3->subs(subs_map));

其中resv1、resv2、resv3为已替换参数的上述方程。请问是否有其他方法可实现高效的参数替换与方程计算，或在SymEngine中是否存在更优实现？注：实际使用的方程规模远大于示例，且每个时间步需多次迭代计算。

一、SymEngine内部优化方案 #

1. 拆分参数与输入变量的替换流程
   把固定参数替换和输入变量替换拆分为两步：在运行时获取参数后，一次性完成参数到常量的替换，得到仅包含输入变量的优化表达式；后续时间步迭代时，只替换输入变量，避免重复处理固定参数的替换逻辑，大幅减少开销。
   示例代码：

   // 初始化阶段：一次性替换固定参数p1/p2/p3
   SymEngine::map_basic_basic param_subs;
   param_subs[p1_sym] = real_double(p1_val); // p1_val为运行时获取的参数值
   param_subs[p2_sym] = real_double(p2_val);
   param_subs[p3_sym] = real_double(p3_val);
   auto optimized_resv1 = resv1->subs(param_subs);
   auto optimized_resv2 = resv2->subs(param_subs);
   auto optimized_resv3 = resv3->subs(param_subs);
   
   // 时间步迭代阶段：仅替换输入变量
   SymEngine::map_basic_basic input_subs;
   while (time_step_loop) {
       input_subs[x_sym] = real_double(x);
       input_subs[y_sym] = real_double(y);
       input_subs[z_sym] = real_double(z);
       input_subs[dx_sym] = real_double(dx);
       input_subs[dy_sym] = real_double(dy);
       input_subs[dz_sym] = real_double(dz);
   
       rval[0] = SymEngine::eval_double(*optimized_resv1->subs(input_subs));
       rval[1] = SymEngine::eval_double(*optimized_resv2->subs(input_subs));
       rval[2] = SymEngine::eval_double(*optimized_resv3->subs(input_subs));
   }
   

2. 使用预编译表达式功能
   SymEngine支持通过LLVM后端将优化后的表达式编译为机器码函数，提前完成表达式的编译工作后，后续调用时直接传入输入变量即可，完全避免每次subs的开销，适合大规模方程的高频迭代场景。

二、脱离符号计算库的替代方案 #

如果符号库的开销仍无法满足需求，针对“参数在周期内恒定”的特性，可采用以下高性能方案：

1. 动态代码生成
   在获取参数后，直接生成包含参数常量的C++代码片段，通过即时编译工具（如libclang、tcc）将代码编译为可执行函数，后续迭代直接调用该函数。这种方法的计算效率接近手写硬编码函数，适合参数周期较长、方程规模大的场景。

2. 手动封装带参数的计算类
   将方程逻辑封装为类，把固定参数作为成员变量，输入变量作为计算函数的参数。这种方式完全避免符号计算开销，是性能最优的方案，4000个参数可打包为结构体或数组传入。
   示例代码：

   struct EquationEvaluator {
       // 存储周期内恒定的参数
       std::array<double, 4000> params;
   
       // 构造时传入所有运行时参数
       EquationEvaluator(const std::array<double, 4000>& param_vals) : params(param_vals) {}
   
       void compute(double x, double y, double z, double dx, double dy, double dz, double rval[3]) {
           // 示例中用params[0]对应p1，params[1]对应p2，params[2]对应p3
           rval[0] = -params[0] * x + params[1] * y * z;
           rval[1] = -rval[0] - params[2] * y * y - dy;
           rval[0] -= dx;
           rval[2] = x + y + z - 1;
           // 其他大规模方程逻辑
       }
   };
   
   // 使用方式
   std::array<double, 4000> param_vals;
   // 填充param_vals为运行时获取的参数值
   EquationEvaluator eval(param_vals);
   while (time_step_loop) {
       eval.compute(x, y, z, dx, dy, dz, rval);
       // 后续迭代逻辑
   }
   

3. 使用表达式模板库
   借助Eigen等支持表达式模板的库，在编译期构建计算逻辑，运行时仅传入参数和输入变量，兼顾灵活性与手写代码级别的性能，适合需要动态调整方程结构但又追求性能的场景。

内容的提问来源于stack exchange，提问作者Manvi