Class Solver

include/cppoptlib/solver/solver.h:157–231

// Specifies a solver implementation (of a given order) for a given function
template <typename FunctionTypeT, typename StateTypeT>
class Solver {
 public:
  using StateType = StateTypeT;
  using FunctionType = FunctionTypeT;

  using ProgressType = Progress<FunctionType, StateType>;
  using CallbackType = std::function<void(
      const FunctionType& func, const StateType&, const ProgressType&)>;

  ProgressType stopping_progress;

 public:
  explicit Solver(const ProgressType& stopping_progress =
                      DefaultStoppingSolverProgress<FunctionType, StateType>())
      : stopping_progress(stopping_progress),
        step_callback_(NoOpCallback<FunctionType, StateType>()) {}

  virtual ~Solver() = default;

  void SetCallback(CallbackType callback) { step_callback_ = callback; }

  virtual void InitializeSolver(const FunctionType& /*function*/,
                                const StateType& /*initial_state*/) = 0;

  virtual std::tuple<StateType, Progress<FunctionType, StateType>> Minimize(
      const FunctionType& function, const StateType& function_state) {
    // Solver state during the optimization.
    ProgressType solver_state;
    // Evaluate `function` once at the user-supplied starting point so the
    // `(value, gradient)` invariant on `FunctionState` is established.  For
    // `AugmentedLagrangeState` and other non-FunctionState types this
    // `if constexpr` branch is skipped and we keep the caller's state as-is.
    StateType current_function_state = function_state;
    if constexpr (IsFunctionState<StateType>::value) {
      current_function_state = StateType(function, function_state.x);
    }

    this->InitializeSolver(function, function_state);

    do {
      this->step_callback_(function, current_function_state, solver_state);

      StateType previous_function_state = current_function_state;
      current_function_state = this->OptimizationStep(
          function, previous_function_state, solver_state);

      // Re-establish the `(value, gradient)` invariant on
      // `current_function_state`.  Solvers that already return a populated
      // state from their line search leave `gradient.size() == x.size()`
      // -- in that case skip the rebuild so the optimization loop pays no
      // redundant evaluation.  Unmigrated solvers return a state with an
      // empty `gradient`; rebuild to keep `Update` and the callback
      // consistent.
      if constexpr (IsFunctionState<StateType>::value) {
        if (current_function_state.gradient.size() !=
            current_function_state.x.size()) {
          current_function_state =
              StateType(function, current_function_state.x);