Class Progress

include/cppoptlib/solver/progress.h:82–328

template <class FunctionType, class StateType>
struct Progress {
  using ScalarType = typename FunctionType::ScalarType;
  using VectorType = typename FunctionType::VectorType;
  using MatrixType = typename FunctionType::MatrixType;

  size_t num_iterations = 0;           // Maximum number of allowed iterations.
  ScalarType x_delta = ScalarType{0};  // Minimum change in parameter vector.
  int x_delta_violations = 0;  // Number of violations in pareameter vector.
  ScalarType f_delta = ScalarType{0};  // Minimum change in cost function.
  int f_delta_violations = 0;          // Number of violations in cost function.
  // When true, `f_delta` is interpreted as `factr * epsmch` in Fortran
  // L-BFGS-B 3.0's `|f_k - f_{k+1}| <= factr * epsmch * max(|f_k|,
  // |f_{k+1}|, 1)` convergence test (i.e. a *relative* tolerance scaled
  // by the current function magnitude).  When false, `f_delta` is an
  // absolute threshold.  Default false; `Lbfgsb` sets it true in its own
  // constructor to match Fortran's convergence test exactly.
  bool f_delta_relative = false;
  ScalarType gradient_norm = ScalarType{0};  // Minimum norm of gradient vector.
  // When true, `gradient_norm` is interpreted as a relative tolerance against
  // the current iterate: the solver stops when
  //     `|g|_inf < gradient_norm * max(1, |x|_inf)`.
  // This matches the convergence tests used by Nocedal's Fortran L-BFGS
  // (`gnorm/xnorm <= eps`) and libLBFGS (`||g|| < epsilon * max(1, ||x||)`)
  // and handles badly-scaled problems where `|x|` is large but the residual
  // is already at its floor (e.g. MGH-10 Meyer converges around
  // |x| ~ 6e3, |g|_inf ~ 6e-2).  When false, `gradient_norm` is an absolute
  // threshold, matching LBFGSpp.
  bool gradient_norm_relative = true;
  ScalarType condition_hessian =
      ScalarType{0};  // Maximum condition number of hessian_t.
  ScalarType constraint_threshold =
      ScalarType{0};  // Minimum norm of constraint violations.
  // Outer-loop KKT-stationarity tolerance.  The constrained solver
  // (`AugmentedLagrangian`) reports `Status::Finished` only when
  // primal feasibility AND Lagrangian-gradient stationarity both
  // hold; `kkt_stationarity_threshold` is the threshold on the
  // measured Lagrangian gradient sup-norm.  A non-positive value
  // disables the check and falls back to feasibility-only stopping.
  //
  // The default is deliberately looser than the inner-solver
  // `gradient_norm` threshold: the outer-loop Lagrangian gradient
  // accumulates roundoff from all constraint evaluations, so a
  // Lagrangian gradient at the `1e-6` level is often unattainable
  // even when every per-constraint residual is at machine epsilon.
  ScalarType kkt_stationarity_threshold = ScalarType{1e-4};
  Status status = Status::NotStarted;  // Status of state.

  // Past-delta stopping: stop when the function value has not decreased
  // meaningfully over the last `past` iterations.  The test fires when
  //     |f_{k-past} - f_k| / max(1, |f_k|) < past_delta.
  // Set `past = 0` to disable (default for backward compatibility).
  // LBFGS-Lite uses past=3, delta=1e-6 and this is a major contributor
  // to its lower nfev count on well-behaved problems.
  int past = 0;
  ScalarType past_delta = ScalarType{1e-6};

  // Ring buffer for the past-delta stopping test (internal state).
  std::vector<ScalarType> past_f_ring_;