Class ProdExpression

include/cppoptlib/function_expressions.h:260–315

template <typename F, typename G,
          DifferentiabilityMode TMode = MinDifferentiability<F, G>::value>
struct ProdExpression
    : public FunctionInterface<typename F::ScalarType, TMode, F::Dimension> {
  static_assert(
      F::Dimension == G::Dimension,
      "Compile-time dimension mismatch: F and G must have the same dimension.");
  static_assert(
      std::is_same<typename F::ScalarType, typename G::ScalarType>::value,
      "Compile-time scalar-type mismatch: F and G must have the same scalar "
      "type.");

  static constexpr int Dimension = F::Dimension;
  using ScalarType = typename F::ScalarType;
  using VectorType = Eigen::Matrix<ScalarType, Dimension, 1>;
  using MatrixType = Eigen::Matrix<ScalarType, Dimension, Dimension>;
  static constexpr DifferentiabilityMode Differentiability = TMode;

  F f;
  G g;

  ProdExpression(const F& f_, const G& g_) : f(f_), g(g_) {}

  virtual ScalarType operator()(const VectorType& x, VectorType* grad = nullptr,
                                MatrixType* hess = nullptr) const override {
    if constexpr (TMode == DifferentiabilityMode::None) {
      return f(x) * g(x);
    } else if constexpr (TMode == DifferentiabilityMode::First) {
      VectorType grad_f(x.size()), grad_g(x.size());
      ScalarType fx = f(x, &grad_f);
      ScalarType gx = g(x, &grad_g);
      if (grad) {
        // Product rule: (f*g)' = f'*g + f*g'
        *grad = gx * grad_f + fx * grad_g;
      }
      return fx * gx;
    } else {  // Second order
      VectorType grad_f(x.size()), grad_g(x.size());
      MatrixType hess_f(x.size(), x.size()), hess_g(x.size(), x.size());
      ScalarType fx = f(x, &grad_f, &hess_f);
      ScalarType gx = g(x, &grad_g, &hess_g);
      if (grad) {
        *grad = gx * grad_f + fx * grad_g;
      }
      if (hess) {
        // Hessian: f''*g + f'*g' (symmetric) + f*g''
        *hess = gx * hess_f + fx * hess_g + grad_f * grad_g.transpose() +
                grad_g * grad_f.transpose();
      }
      return fx * gx;
    }
  }

  virtual std::unique_ptr<FunctionInterface<ScalarType, TMode, Dimension>>
  clone() const override {
    return std::make_unique<ProdExpression<F, G, TMode>>(f, g);
  }
};

// --- Helper Expression for min{0, f(x)}