summary.h

// Copyright 2026 Julien Michot.
// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <variant>
#include <vector>
 
#include <Eigen/Core>
 
#include <tinyopt/cost.h>
#include <tinyopt/math.h>  // Defines Matrix and Vector
#include <tinyopt/stop_reasons.h>
#include <tinyopt/time.h>
#include <tinyopt/traits.h>  // Defines parameters_size_v
 
namespace tinyopt {
 
/***
 *  @brief Struct containing optimization results
 *
 ***/
struct Summary {
  using Scalar = double;

  bool Succeeded() const { return stop_reason >= StopReason::kNone; }

  bool Converged() const {
    return stop_reason >= StopReason::kMinError && stop_reason < StopReason::kMaxIters;
  }

  template <typename M = MatX>
  std::optional<M> Covariance(bool rescaled = false) const {
    using M2 =
        std::conditional_t<traits::is_sparse_matrix_v<M>, SparseMat, MatX>;  // TODO better way?
    if (!std::holds_alternative<M2>(final_hessian)) return {};
    const auto &final_hessian_dense = std::get<M2>(final_hessian);
    const auto &cov = InvCov(final_hessian_dense);
    if (cov) {
      if (rescaled && num_residuals > final_hessian_dense.cols())
        return cov.value() *
               (final_cost * final_cost / (num_residuals - final_hessian_dense.cols()));
      else
        return cov.value();
    }
    return {};
  }
 
  bool has_final_hessian() const { return !std::holds_alternative<std::monostate>(final_hessian); }
  const auto &final_hessian_dense() const { return std::get<MatX>(final_hessian); }
  const auto &final_hessian_sparse() const { return std::get<SparseMat>(final_hessian); }

  Cost final_cost = Cost(std::numeric_limits<Scalar>::max(), 0);
  Scalar final_rerr_dec = std::numeric_limits<Scalar>::max();

  StopReason stop_reason = StopReason::kNone;

  uint16_t num_residuals = 0;  
  uint16_t num_iters = 0;      
  uint8_t num_failures = 0;    
  uint8_t num_consec_failures =
      0;  
 
  TimePoint start_time =
      TimePoint::min();   
  float duration_ms = 0;  

  std::variant<std::monostate, MatX, SparseMat> final_hessian;

  bool num_diff_used = false;


 
  struct History {
#if defined(TINYOPT_ENFORCE_NO_DYNAMIC_ALLOCATIONS)
    std::array<Scalar, 2> errs{};
    std::array<Scalar, 2> deltas2{};
    std::array<bool, 2> successes{};
    std::size_t size = 0;
 
    void Add(Scalar err, Scalar delta2, bool success) {
      const std::size_t index = size == 0 ? 0 : 1;
      errs[index] = err;
      deltas2[index] = delta2;
      successes[index] = success;
      if (size < 2) ++size;
    }
 
    bool empty() const { return size == 0; }
    Scalar last_delta2() const { return deltas2[size == 1 ? 0 : 1]; }
#else
    std::vector<Scalar> errs;     
    std::vector<Scalar> deltas2;  
    std::vector<bool> successes;  
 
    void Add(Scalar err, Scalar delta2, bool success) {
      errs.emplace_back(err);
      deltas2.emplace_back(delta2);
      successes.emplace_back(success);
    }
 
    bool empty() const { return deltas2.empty(); }
    Scalar last_delta2() const { return deltas2.back(); }
#endif
  } hist;

};
 
}  // namespace tinyopt