DualSolver.h

Go to the documentation of this file.

/* Copyright 2020 CNRS-AIST JRL */
 
#pragma once
 
#include <Eigen/Core>
 
#include <jrl-qp/SolverOptions.h>
#include <jrl-qp/api.h>
#include <jrl-qp/defs.h>
#include <jrl-qp/internal/ActiveSet.h>
#include <jrl-qp/internal/SelectedConstraint.h>
#include <jrl-qp/internal/TerminationType.h>
#include <jrl-qp/internal/Workspace.h>
#include <jrl-qp/utils/Logger.h>
#include <jrl-qp/utils/debug.h>
 
namespace jrl::qp
{
class JRLQP_DLLAPI DualSolver
{
public:
  DualSolver();
  DualSolver(int nbVar, int nbCstr, bool useBounds);
 
  virtual ~DualSolver() = default;
 
  void resize(int nbVar, int nbCstr, bool useBounds);
 
  void options(const SolverOptions & options);
 
  WConstVector solution() const;
  WConstVector multipliers() const;
  double objectiveValue() const;
  int iterations() const;
 
  const std::vector<ActivationStatus> & activeSet() const;
 
  void resetActiveSet();
 
protected:
  struct StepLength
  {
    double t1;
    double t2;
    int l;
  };
 
  TerminationStatus solve();
  TerminationStatus terminate(TerminationStatus status);
 
  internal::InitTermination init();
  internal::SelectedConstraint selectViolatedConstraint(const VectorConstRef & x) const;
  void computeStep(VectorRef z, VectorRef r, const internal::SelectedConstraint & sc) const;
  StepLength computeStepLength(const internal::SelectedConstraint & sc,
                               const VectorConstRef & x,
                               const VectorConstRef & u,
                               const VectorConstRef & z,
                               const VectorConstRef & r) const;
  bool addConstraint(const internal::SelectedConstraint & sc);
  bool removeConstraint(int l, VectorRef u);
  virtual double dot(const internal::SelectedConstraint & sc, const VectorConstRef & z);
 
  virtual internal::InitTermination init_() = 0;
  virtual internal::SelectedConstraint selectViolatedConstraint_(const VectorConstRef & x) const = 0;
  virtual void computeStep_(VectorRef z, VectorRef r, const internal::SelectedConstraint & sc) const = 0;
  virtual StepLength computeStepLength_(const internal::SelectedConstraint & sc,
                                        const VectorConstRef & x,
                                        const VectorConstRef & u,
                                        const VectorConstRef & z,
                                        const VectorConstRef & r) const = 0;
  virtual bool addConstraint_(const internal::SelectedConstraint & sc) = 0;
  virtual bool removeConstraint_(int l) = 0;
  virtual double dot_(const internal::SelectedConstraint & sc, const VectorConstRef & z) = 0;
  virtual void resize_(int nbVar, int nbCstr, bool useBounds) = 0;
 
private:
  void resize_p(int nbVar, int nbCstr, bool useBounds);
 
protected:
  SolverOptions options_;
  utils::Logger log_;
 
  int it_; // number of iterations
 
  int nbVar_;
  internal::ActiveSet A_;
 
  double f_;
  internal::Workspace<> work_x_;
  internal::Workspace<> work_z_;
  mutable internal::Workspace<> work_u_;
  mutable internal::Workspace<> work_r_;
  mutable bool needToExpandMultipliers_;
};
 
} // namespace jrl::qp