solver-base.hpp

// BSD 3-Clause License
//
// Copyright (C) 2019-2023, LAAS-CNRS, University of Edinburgh,
//                          Heriot-Watt University
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_CORE_SOLVER_BASE_HPP_
#define CROCODDYL_CORE_SOLVER_BASE_HPP_
 
#include <vector>
 
#include "crocoddyl/core/optctrl/shooting.hpp"
#include "crocoddyl/core/utils/stop-watch.hpp"
 
namespace crocoddyl {
 
class CallbackAbstract;  // forward declaration
static std::vector<Eigen::VectorXd> DEFAULT_VECTOR;
 
enum FeasibilityNorm { LInf = 0, L1 };
 
class SolverAbstract {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  explicit SolverAbstract(boost::shared_ptr<ShootingProblem> problem);
  virtual ~SolverAbstract();
 
  virtual bool solve(
      const std::vector<Eigen::VectorXd>& init_xs = DEFAULT_VECTOR,
      const std::vector<Eigen::VectorXd>& init_us = DEFAULT_VECTOR,
      const std::size_t maxiter = 100, const bool is_feasible = false,
      const double reg_init = NAN) = 0;
 
  virtual void computeDirection(const bool recalc) = 0;
 
  virtual double tryStep(const double steplength = 1) = 0;
 
  virtual double stoppingCriteria() = 0;
 
  virtual const Eigen::Vector2d& expectedImprovement() = 0;
 
  virtual void resizeData();
 
  double computeDynamicFeasibility();
 
  double computeInequalityFeasibility();
 
  double computeEqualityFeasibility();
 
  void setCandidate(
      const std::vector<Eigen::VectorXd>& xs_warm = DEFAULT_VECTOR,
      const std::vector<Eigen::VectorXd>& us_warm = DEFAULT_VECTOR,
      const bool is_feasible = false);
 
  void setCallbacks(
      const std::vector<boost::shared_ptr<CallbackAbstract> >& callbacks);
 
  const std::vector<boost::shared_ptr<CallbackAbstract> >& getCallbacks() const;
 
  const boost::shared_ptr<ShootingProblem>& get_problem() const;
 
  const std::vector<Eigen::VectorXd>& get_xs() const;
 
  const std::vector<Eigen::VectorXd>& get_us() const;
 
  const std::vector<Eigen::VectorXd>& get_fs() const;
 
  bool get_is_feasible() const;
 
  double get_cost() const;
 
  double get_merit() const;
 
  double get_stop() const;
 
  const Eigen::Vector2d& get_d() const;
 
  double get_dV() const;
 
  double get_dPhi() const;
 
  double get_dVexp() const;
 
  double get_dPhiexp() const;
 
  double get_dfeas() const;
 
  double get_feas() const;
 
  double get_ffeas() const;
 
  double get_gfeas() const;
 
  double get_hfeas() const;
 
  double get_ffeas_try() const;
 
  double get_gfeas_try() const;
 
  double get_hfeas_try() const;
 
  double get_preg() const;
 
  double get_dreg() const;
 
  DEPRECATED("Use get_preg for primal-variable regularization",
             double get_xreg() const;)
  DEPRECATED("Use get_preg for primal-variable regularization",
             double get_ureg() const;)
 
  double get_steplength() const;
 
  double get_th_acceptstep() const;
 
  double get_th_stop() const;
 
  double get_th_gaptol() const;
 
  FeasibilityNorm get_feasnorm() const;
 
  std::size_t get_iter() const;
 
  void set_xs(const std::vector<Eigen::VectorXd>& xs);
 
  void set_us(const std::vector<Eigen::VectorXd>& us);
 
  void set_preg(const double preg);
 
  void set_dreg(const double dreg);
 
  DEPRECATED("Use set_preg for primal-variable regularization",
             void set_xreg(const double xreg);)
  DEPRECATED("Use set_preg for primal-variable regularization",
             void set_ureg(const double ureg);)
 
  void set_th_acceptstep(const double th_acceptstep);
 
  void set_th_stop(const double th_stop);
 
  void set_th_gaptol(const double th_gaptol);
 
  void set_feasnorm(const FeasibilityNorm feas_norm);
 
 protected:
  boost::shared_ptr<ShootingProblem> problem_;  
  std::vector<Eigen::VectorXd> xs_;             
  std::vector<Eigen::VectorXd> us_;             
  std::vector<Eigen::VectorXd> fs_;  
  std::vector<boost::shared_ptr<CallbackAbstract> >
      callbacks_;      
  bool is_feasible_;   
  bool was_feasible_;  
  double cost_;        
  double merit_;       
  double stop_;        
  Eigen::Vector2d d_;  
  double dV_;       
  double dPhi_;     
  double dVexp_;    
  double dPhiexp_;  
  double dfeas_;    
  double feas_;     
  double
      ffeas_;  
  double gfeas_;  
  double hfeas_;  
  double ffeas_try_;  
  double gfeas_try_;  
  double hfeas_try_;  
  double preg_;       
  double dreg_;       
  DEPRECATED("Use preg_ for primal-variable regularization",
             double xreg_;)  
  DEPRECATED("Use dreg_ for primal-variable regularization",
             double ureg_;)        
  double steplength_;              
  double th_acceptstep_;           
  double th_stop_;                 
  double th_gaptol_;               
  enum FeasibilityNorm feasnorm_;  
  std::size_t iter_;  
  double tmp_feas_;   
};
 
class CallbackAbstract {
 public:
  CallbackAbstract() {}
  virtual ~CallbackAbstract() {}
 
  virtual void operator()(SolverAbstract& solver) = 0;
};
 
bool raiseIfNaN(const double value);
 
}  // namespace crocoddyl
 
#endif  // CROCODDYL_CORE_SOLVER_BASE_HPP_