QPSolverBasicStructures.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_QPSOLVERBASICSTRUCTURES_HXX
#define CONICBUNDLE_QPSOLVERBASICSTRUCTURES_HXX

#include <vector>
#include "clock.hxx"
#include "QPModelBlock.hxx"
#include "QPSolverParameters.hxx"
#include "SOCIPProxBlock.hxx"

namespace ConicBundle {



class QPSolverBasicInterface: public virtual CBout
{
public:
  virtual ~QPSolverBasicInterface();

  //------------------------------------------------------------

  virtual CH_Matrix_Classes::Integer QPget_xdim() const=0;

  virtual CH_Matrix_Classes::Integer QPget_ydim() const=0;

  virtual CH_Matrix_Classes::Matrix& QPadd_Qx(const CH_Matrix_Classes::Matrix& vecin,CH_Matrix_Classes::Matrix& vecout) const =0;

  virtual CH_Matrix_Classes::Matrix& QPadd_Ax(const CH_Matrix_Classes::Matrix& xin,CH_Matrix_Classes::Matrix& outplusAx) const =0;

  virtual CH_Matrix_Classes::Matrix& QPadd_Aty(const CH_Matrix_Classes::Matrix& yin,CH_Matrix_Classes::Matrix& outplusAty) const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_c() const =0;

  virtual CH_Matrix_Classes::Real QPget_gamma() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_rhslb() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_rhsub() const =0;

  virtual const CH_Matrix_Classes::Indexmatrix& QPget_rhslbind() const =0;

  virtual const CH_Matrix_Classes::Indexmatrix& QPget_rhsubind() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_lb() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_ub() const =0;
  
  virtual const CH_Matrix_Classes::Indexmatrix& QPget_lbind() const =0;

  virtual const CH_Matrix_Classes::Indexmatrix& QPget_ubind() const =0;

  //------------------------------------------------------------

  virtual void QPIclear()=0;

  virtual int QPset_solver_parameters(QPSolverParameters* params)=0;

  virtual int QPset_startx(const CH_Matrix_Classes:: Matrix& startx)=0;

  virtual int QPset_starts(const CH_Matrix_Classes::Matrix& starts)=0;

  virtual int QPset_starty(const CH_Matrix_Classes::Matrix& starty)=0;

  virtual int QPset_startzlb(const CH_Matrix_Classes::Matrix& startlb)=0;

  virtual int QPset_startzub(const CH_Matrix_Classes::Matrix& startub)=0;

  virtual int QPset_startmu(CH_Matrix_Classes::Real startmu)=0;

  virtual int QPIsolve(bool reinitialize=true,CH_Matrix_Classes::Real skip_factor=-1.)=0;

  virtual CH_Matrix_Classes::Real QPget_primalval() const =0;

  virtual CH_Matrix_Classes::Real QPget_dualval() const =0;

  virtual QPSolverParameters* QPget_parameters() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_x() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_y() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_zlb() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_zub() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_s() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_rhszlb() const =0;

  virtual const CH_Matrix_Classes::Matrix& QPget_rhszub() const =0;

  virtual CH_Matrix_Classes::Real QPget_mu() const =0;
  

};


class QPCentralPathPoint
{
public:
  CH_Matrix_Classes::Matrix x;
  
  CH_Matrix_Classes::Matrix y;

  CH_Matrix_Classes::Matrix s;

  CH_Matrix_Classes::Matrix zlb;

  CH_Matrix_Classes::Matrix zub;

  CH_Matrix_Classes::Matrix rhszlb;

  CH_Matrix_Classes::Matrix rhszub;

  CH_Matrix_Classes::Real mu;

  QPCentralPathPoint& operator=(const QPCentralPathPoint& ppp)
  { 
    x=ppp.x;
    y=ppp.y;
    s=ppp.s;
    zlb=ppp.zlb;
    zub=ppp.zub;
    rhszlb=ppp.rhszlb;
    rhszub=ppp.rhszub;
    mu=ppp.mu;
    return *this;
  }
    
  QPCentralPathPoint(){}

  QPCentralPathPoint(const QPCentralPathPoint& ppp)
  {*this=ppp;}

  QPCentralPathPoint(
                         const CH_Matrix_Classes::Matrix& ix,
                         const CH_Matrix_Classes::Matrix& iy,
                         const CH_Matrix_Classes::Matrix& is,
                         const CH_Matrix_Classes::Matrix& izlb,
                         const CH_Matrix_Classes::Matrix& izub,
                         const CH_Matrix_Classes::Matrix& irhszlb,
                         const CH_Matrix_Classes::Matrix& irhszub,
                         const CH_Matrix_Classes::Real imu
                         ):
    x(ix),y(iy),s(is),zlb(izlb),zub(izub),rhszlb(irhszlb),rhszub(irhszub),mu(imu){}

};



class QPSolverBasicStructures: public QPSolverBasicInterface, public QPModelPointer, public virtual QPSolverObject
{
private:
  QPSolverParameters* paramsp;   

  CH_Matrix_Classes::Matrix x;          
  CH_Matrix_Classes::Matrix y;          
  CH_Matrix_Classes::Matrix s;          
  CH_Matrix_Classes::Matrix zlb;        
  CH_Matrix_Classes::Matrix zub;        
  CH_Matrix_Classes::Matrix rhszlb;     
  CH_Matrix_Classes::Matrix rhszub;     
 
  CH_Matrix_Classes::Real mu;           
 
  CH_Matrix_Classes::Real last_mu;      
  CH_Matrix_Classes::Real next_mu;      
  
  CH_Matrix_Classes::Real last_theta;      
  CH_Matrix_Classes::Real next_theta;      
  
  CH_Matrix_Classes::Real last_alpha;   

  CH_Matrix_Classes::Real sigma;        
 
  CH_Matrix_Classes::Integer iter;      
  CH_Matrix_Classes::Integer large_predictor_cnt;  
  
  std::vector<QPCentralPathPoint> central_path;  

  CH_Matrix_Classes::Real primalval;      
  CH_Matrix_Classes::Real dualval;        

  CH_Matrix_Classes::Matrix primalviol;     
  CH_Matrix_Classes::Matrix dualviol;       
  CH_Matrix_Classes::Matrix yviol;          
  CH_Matrix_Classes::Real n2primalviol;       
  CH_Matrix_Classes::Real n2dualviol;         
  CH_Matrix_Classes::Real n2modelprimalviol;  
  CH_Matrix_Classes::Real n2modeldualviol;    
  CH_Matrix_Classes::Real n2yviol;             
  
  CH_Matrix_Classes::Matrix shortzlb;    
  CH_Matrix_Classes::Matrix shortzub;    
  CH_Matrix_Classes::Matrix slacklb;     
  CH_Matrix_Classes::Matrix slackub;     

  CH_Matrix_Classes::Matrix shortrhszlb; 
  CH_Matrix_Classes::Matrix shortrhszub; 
  CH_Matrix_Classes::Matrix rhsslacklb;  
  CH_Matrix_Classes::Matrix rhsslackub;  

  CH_Matrix_Classes::Matrix dshortzlb;    
  CH_Matrix_Classes::Matrix dshortzub;    
  CH_Matrix_Classes::Matrix dslacklb;     
  CH_Matrix_Classes::Matrix dslackub;     

  CH_Matrix_Classes::Matrix dshortrhszlb; 
  CH_Matrix_Classes::Matrix dshortrhszub; 
  CH_Matrix_Classes::Matrix drhsslacklb;  
  CH_Matrix_Classes::Matrix drhsslackub;  

  CH_Matrix_Classes::Matrix solx;  
  CH_Matrix_Classes::Matrix soly;  

  CH_Matrix_Classes::Matrix old_x;          
  CH_Matrix_Classes::Matrix old_y;          
  CH_Matrix_Classes::Matrix old_s;          
  CH_Matrix_Classes::Matrix old_zlb;        
  CH_Matrix_Classes::Matrix old_zub;        
  CH_Matrix_Classes::Matrix old_rhszlb;     
  CH_Matrix_Classes::Matrix old_rhszub;     
  CH_Matrix_Classes::Real old_mu; 
 


  SOCIPProxBlock socqp; 

  int QPcompute_values(bool init);

  void QPvec_linesearch(CH_Matrix_Classes::Real& alpha,
                         const CH_Matrix_Classes::Matrix& vec,
                         const CH_Matrix_Classes::Matrix& dvec) const;

  void QPlinesearch(CH_Matrix_Classes::Real& alpha);

  virtual int QPselect_mu(CH_Matrix_Classes::Real& mu,
                          CH_Matrix_Classes::Real alpha);

  virtual int QPselect_step_mu(CH_Matrix_Classes::Real& mu,
                               CH_Matrix_Classes::Real& alpha,
                               bool centering);

  virtual int QPselect_localstep_mu(CH_Matrix_Classes::Real& mu,
                               CH_Matrix_Classes::Real& alpha,
                               bool centering);

  int QPpredcorr_step(CH_Matrix_Classes::Real& alpha,   
                      CH_Matrix_Classes::Real& prec,    
                      CH_Matrix_Classes::Real& next_mu, 
                      bool use_predcorr,                
                      bool use_nbh,                     
                      bool centering                    
                      );

  int QPiterate();
  
protected:

  //Statistics
  mutable CH_Tools::Clock clock;  
  mutable CH_Tools::Microseconds QPcoeff_time;  
  mutable CH_Tools::Microseconds QPsolve_time; 
  mutable CH_Tools::Microseconds QPinitKKT_time; 
  mutable CH_Tools::Microseconds QPpredictor_time; 
  mutable CH_Tools::Microseconds QPcorrector_time; 
  mutable CH_Tools::Microseconds QPlinesearch_time; 
  mutable CH_Tools::Microseconds QPcurrentprecprep_time; 
  mutable CH_Tools::Microseconds QPprecprep_time; 
  mutable CH_Tools::Microseconds QPprecprepmodel_time; 
  mutable CH_Tools::Microseconds QPprecsolve_time; 
  mutable CH_Tools::Microseconds QPmatmult_time; 
  mutable CH_Tools::Microseconds QP_time; 

public:
  QPSolverBasicStructures(QPSolverParameters* params=0,CBout* cb=0);
  virtual ~QPSolverBasicStructures(){delete paramsp;paramsp=0;}

  
  virtual void QPIclear();
  
  virtual int QPset_solver_parameters(QPSolverParameters* params)
  {assert(params); if(params!=0){delete paramsp;paramsp=params;} return 0;}
  
  virtual int QPset_startx(const CH_Matrix_Classes::Matrix& startx)
  {assert(startx.dim()==QPget_xdim()); x=startx; return 0;}

  virtual int QPset_starts(const CH_Matrix_Classes::Matrix& starts)
  {assert(starts.dim()==QPget_ydim()); s=starts; return 0;}

  virtual int QPset_starty(const CH_Matrix_Classes::Matrix& starty)
  {assert(starty.dim()==QPget_ydim()); y=starty; return 0;}

  virtual int QPset_startzlb(const CH_Matrix_Classes::Matrix& startzlb)
  {assert(startzlb.dim()==QPget_xdim()); zlb=startzlb; return 0;}

  virtual int QPset_startzub(const CH_Matrix_Classes::Matrix& startzub)
  {assert(startzub.dim()==QPget_xdim()); zub=startzub; return 0;}

  virtual int QPset_startmu(CH_Matrix_Classes::Real startmu)
  {mu=startmu; return 0;}

  virtual int QPIsolve(bool reinitialize=true,CH_Matrix_Classes::Real skip_factor=-1.);

  virtual CH_Matrix_Classes::Real QPget_primalval() const {return primalval;}

  virtual CH_Matrix_Classes::Real QPget_dualval() const {return dualval;}

  virtual QPSolverParameters* QPget_parameters() const {return paramsp;}

  virtual const CH_Matrix_Classes::Matrix& QPget_x() const {return x;}

  virtual int QPget_x(CH_Matrix_Classes::Matrix& xout,
                      CH_Matrix_Classes::Indexmatrix& x_activity) const;

  virtual const CH_Matrix_Classes::Matrix& QPget_y() const {return y;}  

  virtual const CH_Matrix_Classes::Matrix& QPget_zlb() const {return zlb;}

  virtual const CH_Matrix_Classes::Matrix& QPget_zub() const {return zub;}

  virtual const CH_Matrix_Classes::Matrix& QPget_s() const {return s;}

  virtual int QPget_s(CH_Matrix_Classes::Matrix& sout,
                      CH_Matrix_Classes::Indexmatrix& s_activity) const;

  virtual const CH_Matrix_Classes::Matrix& QPget_rhszlb() const {return rhszlb;}

  virtual const CH_Matrix_Classes::Matrix& QPget_rhszub() const {return rhszub;}

  virtual const SOCIPProxBlock& QPget_socqp() const {return socqp;} 

  virtual SOCIPProxBlock& QPset_socqp() {return socqp;} 

  virtual CH_Matrix_Classes::Real QPget_mu() const {return mu;}

  virtual CH_Matrix_Classes::Integer QPget_large_predictor_cnt() const {return large_predictor_cnt;}

  virtual CH_Matrix_Classes::Integer QPget_iter() const {return iter;}
};



}

#endif