Method Update

include/cppoptlib/solver/progress.h:153–327

Updates state from function information. For plain `FunctionState`, the `(value, gradient)` invariant means we can read the numbers we need directly from the two state arguments instead of calling `function()` again. The `AugmentedLagrangeState` branch still re-evaluates because the augmented-Lagrangian objective is a *composite* built from `function`, the multipliers, and the penalty, none of w

  // penalty, none of which are stored as a cached `(value, gradient)` on
  // the state itself.
  void Update(const FunctionType& function,
              const StateType& previous_function_state,
              const StateType& current_function_state,
              const Progress<FunctionType, StateType>& stop_progress) {
    const VectorType& current_x = current_function_state.x;
    const VectorType& previous_x = previous_function_state.x;
    VectorType previous_gradient, current_gradient;
    ScalarType previous_value;
    ScalarType current_value;
    if constexpr (StateType::IsConstrained) {
      // Augmented-Lagrangian path: value/gradient live in the composite
      // objective, not on the state, so we still evaluate here.
      const auto previous_function = cppoptlib::function::ToAugmentedLagrangian(
          function, previous_function_state.multiplier_state,
          previous_function_state.penalty_state);
      const auto current_function = cppoptlib::function::ToAugmentedLagrangian(
          function, current_function_state.multiplier_state,
          current_function_state.penalty_state);

      previous_value = previous_function(previous_x, &previous_gradient);
      current_value = current_function(current_x, &current_gradient);
    } else if constexpr (FunctionType::Differentiability >=
                         cppoptlib::function::DifferentiabilityMode::First) {
      // FunctionState path: read cached (value, gradient) populated by the
      // solver/line search -- no redundant function() calls.
      previous_value = previous_function_state.value;
      current_value = current_function_state.value;
      previous_gradient = previous_function_state.gradient;
      current_gradient = current_function_state.gradient;
    } else {
      // None-mode FunctionState: only value is tracked.
      previous_value = previous_function_state.value;
      current_value = current_function_state.value;
    }

    num_iterations++;
    f_delta = std::abs(current_value - previous_value);
    x_delta = (current_x - previous_x).template lpNorm<Eigen::Infinity>();

    // Compute gradient norm if the function supports differentiation
    if constexpr (FunctionType::Differentiability >=
                  cppoptlib::function::DifferentiabilityMode::First) {
      gradient_norm = current_gradient.template lpNorm<Eigen::Infinity>();
    }
    // Compute Hessian condition number if the function supports second-order
    // derivatives.  Gated on `!StateType::IsConstrained` so
    // constrained-solver state types (`AugmentedLagrangeState`) skip it:
    // their `FunctionType` is `ConstrainedOptimizationProblem`, which
    // has no `operator()` -- the solver evaluates objective and
    // constraints separately via the struct's member fields.
    if constexpr (!StateType::IsConstrained &&
                  FunctionType::Differentiability ==
                      cppoptlib::function::DifferentiabilityMode::Second) {
      MatrixType current_hessian;
      function(current_x, nullptr, &current_hessian);
      condition_hessian =
          current_hessian.norm() * current_hessian.inverse().norm();
    }