Class FunctionState

include/cppoptlib/function_base.h:298–332

// that showed up in traces against libLBFGS and L-BFGS-B Fortran 3.0.
template <typename TScalar, int TDimension = Eigen::Dynamic>
struct FunctionState {
  // Plain unconstrained state; `Progress::Update` uses this to pick the
  // gradient/f-delta convergence branch rather than the feasibility
  // branch that `AugmentedLagrangeState` takes.
  static constexpr bool IsConstrained = false;
  using ScalarType = TScalar;
  using VectorType = Eigen::Matrix<TScalar, TDimension, 1>;

  VectorType x;
  ScalarType value = ScalarType{0};
  VectorType gradient;  // empty for DifferentiabilityMode::None.

  // Legacy x-only constructor.  Leaves value = 0 and gradient = empty; the
  // caller must populate them before the state is consumed by the new
  // eval-free code paths.  Kept so existing user code that writes
  // `FunctionState(x0)` continues to compile; the outer solver `Minimize`
  // will evaluate `function(x)` once and rebuild a fully-populated state.
  explicit FunctionState(VectorType x_in) : x(std::move(x_in)) {}

  // Evaluate `function` at `x` once and populate all fields.
  template <class FunctionT>
  FunctionState(const FunctionT& function, VectorType x_in)
      : x(std::move(x_in)) {
    if constexpr (FunctionT::Differentiability == DifferentiabilityMode::None) {
      value = function(x);
    } else {
      value = function(x, &gradient);
    }
  }

  // Trust-me constructor: caller has already computed `value` and `gradient`
  // at `x` (typically the line search's last internal evaluation).
  FunctionState(VectorType x_in, ScalarType value_in, VectorType gradient_in)
      : x(std::move(x_in)), value(value_in), gradient(std::move(gradient_in)) {}
};

template <typename TScalar, int TDimension>
FunctionState(Eigen::Matrix<TScalar, TDimension, 1>)