Class ModeDowngradeAdapter

include/cppoptlib/function_base.h:151–189

template <typename TScalar, DifferentiabilityMode SourceMode,
          DifferentiabilityMode TargetMode, int TDimension>
struct ModeDowngradeAdapter
    : public FunctionInterface<TScalar, TargetMode, TDimension> {
  static_assert(static_cast<int>(SourceMode) >= static_cast<int>(TargetMode),
                "ModeDowngradeAdapter only lowers the differentiability mode "
                "-- attempting to upgrade.");

  using VectorType = Eigen::Matrix<TScalar, TDimension, 1>;
  using MatrixType = Eigen::Matrix<TScalar, TDimension, TDimension>;

  std::unique_ptr<FunctionInterface<TScalar, SourceMode, TDimension>> source;

  explicit ModeDowngradeAdapter(
      std::unique_ptr<FunctionInterface<TScalar, SourceMode, TDimension>> s)
      : source(std::move(s)) {}

  TScalar operator()(const VectorType& x, VectorType* grad = nullptr,
                     MatrixType* hess = nullptr) const override {
    (void)hess;  // Never forwarded -- the target mode does not expose it.
    if constexpr (TargetMode == DifferentiabilityMode::None) {
      (void)grad;
      return (*source)(x, nullptr, nullptr);
    } else if constexpr (TargetMode == DifferentiabilityMode::First) {
      return (*source)(x, grad, nullptr);
    } else {
      // TargetMode == Second: SourceMode must also be Second by the
      // static_assert above, in which case the adapter is a no-op and
      // nothing should ever construct it at this branch.  Keep the path
      // defined in case some future code wires it up.
      return (*source)(x, grad, hess);
    }
  }

  std::unique_ptr<FunctionInterface<TScalar, TargetMode, TDimension>> clone()
      const override {
    return std::make_unique<
        ModeDowngradeAdapter<TScalar, SourceMode, TargetMode, TDimension>>(
        source->clone());
  }
};

template <typename TScalar,
          DifferentiabilityMode TMode = DifferentiabilityMode::First,