results.hpp

Go to the documentation of this file.

#pragma once
 
#include "proxsuite-nlp/problem-base.hpp"
#include "proxsuite-nlp/fmt-eigen.hpp"
 
namespace proxsuite {
namespace nlp {
 
enum ConvergenceFlag { UNINIT = -1, SUCCESS = 0, MAX_ITERS_REACHED = 1 };
inline auto format_as(ConvergenceFlag fl) { return fmt::underlying(fl); }

template <typename _Scalar> struct ResultsTpl {
  using Scalar = _Scalar;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
  using Problem = ProblemTpl<Scalar>;
  using VecBool = Eigen::Matrix<bool, Eigen::Dynamic, 1>;
 
  ConvergenceFlag converged = SUCCESS;
 
  Scalar merit;
  Scalar value;
  VectorXs x_opt;
  VectorXs data_lams_opt;
  VectorOfRef lams_opt;
  std::vector<VecBool> active_set;
  Scalar dual_infeas = 0.;
  Scalar prim_infeas = 0.;
  VectorXs constraint_violations;

  std::size_t num_iters = 0;
  std::size_t al_iters = 0;
  Scalar mu;
  Scalar rho;
 
  ResultsTpl(const Problem &prob)
      : x_opt(prob.manifold_->neutral()),
        data_lams_opt(prob.getTotalConstraintDim()),
        constraint_violations(prob.getNumConstraints()), num_iters(0), mu(0.),
        rho(0.) {
    helpers::allocateMultipliersOrResiduals(prob, data_lams_opt, lams_opt);
    constraint_violations.setZero();
    active_set.reserve(prob.getNumConstraints());
    for (std::size_t i = 0; i < prob.getNumConstraints(); i++) {
      active_set.push_back(VecBool::Zero(prob.getConstraint(i).func().nr()));
    }
  }
 
  friend std::ostream &operator<<(std::ostream &oss,
                                  const ResultsTpl<Scalar> &self) {
    oss << "Results {" << fmt::format("\n  convergence:   {},", self.converged)
        << fmt::format("\n  merit:         {:.3e},", self.merit)
        << fmt::format("\n  value:         {:.3e},", self.value)
        << fmt::format("\n  num_iters:     {:d},", self.num_iters)
        << fmt::format("\n  mu:            {:.3e},", self.mu)
        << fmt::format("\n  rho:           {:.3e},", self.rho)
        << fmt::format("\n  dual_infeas:   {:.3e},", self.dual_infeas)
        << fmt::format("\n  prim_infeas:   {:.3e},", self.prim_infeas)
        << fmt::format("\n  cstr_values:   {}",
                       self.constraint_violations.transpose());
    for (std::size_t i = 0; i < self.active_set.size(); i++) {
      oss << fmt::format("\n  activeSet[{:d}]:  {}", i,
                         self.active_set[i].transpose());
    }
    oss << "\n}";
    return oss;
  }
};
 
} // namespace nlp
} // namespace proxsuite
 
template <typename Scalar>
struct fmt::formatter<::proxsuite::nlp::ResultsTpl<Scalar>>
    : fmt::ostream_formatter {};
 
#ifdef PROXSUITE_NLP_ENABLE_TEMPLATE_INSTANTIATION
#include "proxsuite-nlp/results.txx"
#endif