BundleSolver.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_BUNDLESOLVER_HXX
#define CONICBUNDLE_BUNDLESOLVER_HXX


#include "clock.hxx"
#include "QPSolverObject.hxx"
#include "Groundset.hxx"
#include "BundleModel.hxx"
#include "BundleWeight.hxx"
#include "BundleTerminator.hxx"


namespace ConicBundle {



class BundleSolver: public BundleTerminatorData, public CBout
{
private:
  //-----------------------------------------------------------------------

  BundleModel *model;       

  Groundset* groundset;
  bool external_groundset;

  BundleTerminator *terminator; 

  BundleWeight *bundleweight;  

  
  const CH_Tools::Clock* clockp;  


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

  CH_Matrix_Classes::Real mL;             
  CH_Matrix_Classes::Real mN;
  bool use_linval;      
  CH_Matrix_Classes::Real modeleps;       
  CH_Matrix_Classes::Integer max_updates; 

  BundleProxObject* Hp;

  int do_variable_metric; 
  
  bool check_center_validity;



  //-----------------------------------------------------------------------
  
  CH_Matrix_Classes::Integer point_id; 

  CH_Matrix_Classes::Integer center_id;  
  CH_Matrix_Classes::Matrix center_y; 
  CH_Matrix_Classes::Integer center_fid; 
  CH_Matrix_Classes::Real center_ub;     
  CH_Matrix_Classes::Real center_relprec; 
  CH_Matrix_Classes::Integer center_gid; 
  CH_Matrix_Classes::Real center_gs_val;


  CH_Matrix_Classes::Integer cand_id;     
  CH_Matrix_Classes::Matrix cand_y;  
  CH_Matrix_Classes::Integer cand_fid;    
  CH_Matrix_Classes::Real cand_ub;        
  CH_Matrix_Classes::Real cand_relprec;   
  CH_Matrix_Classes::Integer cand_gid;
  CH_Matrix_Classes::Real cand_gs_val;
 
  MinorantPointer model_aggregate;  
  CH_Matrix_Classes::Integer model_aggregate_id; 
 



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

  CH_Matrix_Classes::Real augval_lb;
  CH_Matrix_Classes::Real augval_ub;
  CH_Matrix_Classes::Real linval;
  CH_Matrix_Classes::Real cutval;
  CH_Matrix_Classes::Real modelval;
  CH_Matrix_Classes::Real modelprec;

  CH_Matrix_Classes::Real weightu;
  CH_Matrix_Classes::Real aggr_dnormsqr;    

  bool descent_step;        
  bool null_step;           

  int retcode;
  int terminate;               

   

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

  QPSolverObject *qp_solver;  

  bool qp_solves_model_without_gs;

  CH_Tools::Microseconds QPcoeff_time;  
  CH_Tools::Microseconds QPsolve_time; 
  CH_Tools::Microseconds make_aggr_time; 
  CH_Tools::Microseconds evalaugmodel_time; 
  mutable int qp_save_cnt;

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

  bool might_be_modified;
  bool initialize_model;
  bool use_cand_for_aggregate;

  CH_Matrix_Classes::Integer updatecnt;
  CH_Matrix_Classes::Integer sumupdatecnt;
  CH_Matrix_Classes::Integer innerit;    
  CH_Matrix_Classes::Integer suminnerit; 
  CH_Matrix_Classes::Integer cntobjeval; 
  CH_Matrix_Classes::Integer recomp;     
  CH_Matrix_Classes::Integer sumrecomp;  //sum over all recomputations
  CH_Matrix_Classes::Integer qpfails;      //counts number of fails in calls to eval_aug_model
  CH_Matrix_Classes::Integer sumqpfails;   
  CH_Matrix_Classes::Integer modelfails; 
  CH_Matrix_Classes::Integer summodelfails;//sums up number of fails
  CH_Matrix_Classes::Integer augvalfails; 
  CH_Matrix_Classes::Integer sumaugvalfails;  
  CH_Matrix_Classes::Integer oraclefails; 
  CH_Matrix_Classes::Integer sumoraclefails;//sums up number of fails

  CH_Matrix_Classes::Integer descent_steps;        //counts number of descent_steps
  CH_Matrix_Classes::Integer shallowcut;      


  //-----------------------------------------------------------------------
  int variable_metric(const CH_Matrix_Classes::Indexmatrix* new_indices=0);

  int solve_model(void);

  int eval_augmodel(CH_Matrix_Classes::Real& augval_lb,
                    CH_Matrix_Classes::Integer& center_ub_fid, 
                    CH_Matrix_Classes::Real& center_ub,
                    CH_Matrix_Classes::Real relprec,
                    CH_Matrix_Classes::Real center_gs_value);
             
  int reeval_augmodel(CH_Matrix_Classes::Real& augval_lb,
                      CH_Matrix_Classes::Integer& center_ub_fid, 
                      CH_Matrix_Classes::Real& center_ub,
                      CH_Matrix_Classes::Real relprec,
                      CH_Matrix_Classes::Real center_gs_value,
                      const MinorantPointer& delta_gs_minorant,
                      const CH_Matrix_Classes::Indexmatrix& delta_index);

    
public:

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

  BundleSolver(const CBout* cbo=0,int incr=-1);

  BundleSolver(CH_Matrix_Classes::Integer dim, BundleModel* bp=0,const CBout* cbo=0,int incr=-1);

  BundleSolver(Groundset* gs,BundleModel* bp=0,const CBout* cbo=0,int incr=-1);

  ~BundleSolver();
        
  void set_defaults();  

  void clear(); 

  void clear_fails();  

  int initialize(CH_Matrix_Classes::Integer dim, BundleModel* bp=0);

  int initialize(Groundset* gs,BundleModel* bp=0);

  void set_out(std::ostream* o=0,int pril=1)
  {
    CBout::set_out(o,pril);
  }

  void set_cbout(const CBout* cb,int incr)
  {
    CBout::set_out(cb->get_out_ptr(),cb->get_print_level()+incr);
  }

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

  int set_model(BundleModel* bp);

  int set_new_center(const CH_Matrix_Classes::Matrix* yp=0);  // yp==0 uses default starting point

  int solve(int maxsteps=0,bool stop_at_descent_steps=false);
  
  std::ostream& print_line_summary(std::ostream& out) const;

  int apply_modification(const GroundsetModification& gsmdf,const FunObjModMap& funmdfmap);

  int apply_modification(const GroundsetModification& gsmdf)
  {
    FunObjModMap funmdfmap; 
    return apply_modification(gsmdf,funmdfmap);
  }

  

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

  void set_terminator(BundleTerminator* bt)
  {delete terminator; terminator=bt;}

  void set_bundleweight(BundleWeight* bw);

  void set_modeleps(CH_Matrix_Classes::Real in_eps)
  {if (in_eps>0.) modeleps=in_eps;}

  void set_mL(CH_Matrix_Classes::Real in_mL)
  {if ((in_mL>0)&&(in_mL<1.)) mL=in_mL;}

  void set_mN(CH_Matrix_Classes::Real in_mN)
  {if ((in_mN>=mL)&&(in_mN<1.)) mN=in_mN;}

  void set_use_linval(bool ul)
  {use_linval=ul;}

  void set_do_yfixing(bool dofix){groundset->set_use_yfixing(dofix);}

  int set_variable_metric(int ds);  
  
  int set_prox_diagonal(const CH_Matrix_Classes::Matrix& insc);

  int set_prox(BundleProxObject* bsp);

  void set_clock(const CH_Tools::Clock& myclock)
  {clockp=&myclock;}

  void set_max_updates(CH_Matrix_Classes::Integer mu)
  {max_updates=mu;}
    

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

  int get_terminate() const 
  {return terminate;}

  CH_Matrix_Classes::Real get_center_objval() const 
  {return center_ub+center_gs_val;}
  CH_Matrix_Classes::Real get_center_ub() const 
  {return center_ub;}
  CH_Matrix_Classes::Real get_center_gs_val() const 
  {return center_gs_val;}
  const CH_Matrix_Classes::Matrix& get_center_y() const 
  {return center_y;} 

  CH_Matrix_Classes::Real get_cand_objval() const 
  {return cand_ub+cand_gs_val;}
  CH_Matrix_Classes::Real get_cand_ub() const 
  {return cand_ub;}
  CH_Matrix_Classes::Real get_cand_gs_val() const 
  {return cand_gs_val;}
  const CH_Matrix_Classes::Matrix& get_cand_y() const 
  {return cand_y;} 

  CH_Matrix_Classes::Real get_aggr_dnormsqr() const 
  {return aggr_dnormsqr;}
  CH_Matrix_Classes::Real get_aggregate_offset() const 
  {return groundset->get_gs_aggregate().offset()+model_aggregate.offset();}
  void get_aggregate(CH_Matrix_Classes::Matrix& aggregate) const 
  {
    CH_Matrix_Classes::Real dummy;
    aggregate.init(groundset->get_dim(),1,0.); 
    model_aggregate.get_minorant(dummy,aggregate,0,1.,false);
    groundset->get_gs_aggregate().get_minorant(dummy,aggregate,0,1.,true);
  }

  const MinorantPointer& get_gs_aggregate() const 
  {return groundset->get_gs_aggregate();}
 
  const MinorantPointer& get_model_aggregate() const 
  {return model_aggregate;} 
  
  CH_Matrix_Classes::Real get_modelval() const 
  {return modelval;}

  CH_Matrix_Classes::Real get_weight() const {return Hp->get_weightu();}
  CH_Matrix_Classes::Real get_term_corr() const {return Hp->get_term_corr();}

  bool get_descent_step() const {return descent_step;}
  bool get_null_step() const {return null_step;}

  const CH_Matrix_Classes::Indexmatrix* get_yfixed() const {return groundset->get_yfixed();}



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


  CH_Matrix_Classes::Real get_modeleps() const {return modeleps;}
  int get_use_linval() const {return use_linval;}
  int get_do_variable_metric() const {return do_variable_metric;}
  bool get_use_variable_metric() const {return Hp->employ_variable_metric();}
    
  CH_Matrix_Classes::Integer get_cntobjeval() const {return cntobjeval;}
  CH_Matrix_Classes::Integer get_descent_steps() const {return descent_steps;}
  CH_Matrix_Classes::Integer get_innerit() const {return innerit;}
  CH_Matrix_Classes::Integer get_suminnerit() const {return suminnerit;}
  CH_Matrix_Classes::Integer get_sumupdatecnt() const {return sumupdatecnt;}
  CH_Matrix_Classes::Integer get_recomp() const {return recomp;}
  CH_Matrix_Classes::Integer get_sumrecomp() const {return sumrecomp;} 
  CH_Matrix_Classes::Integer get_qpfails() const {return qpfails;}
  CH_Matrix_Classes::Integer get_sumqpfails() const {return sumqpfails;}
  CH_Matrix_Classes::Integer get_modelfails() const {return modelfails;}
  CH_Matrix_Classes::Integer get_summodelfails() const {return summodelfails;}
  CH_Matrix_Classes::Integer get_augvalfails() const {return augvalfails;}
  CH_Matrix_Classes::Integer get_sumaugvalfails() const {return sumaugvalfails;}
  CH_Matrix_Classes::Integer get_oraclefails() const {return oraclefails;}
  CH_Matrix_Classes::Integer get_sumoraclefails() const {return sumoraclefails;}

  CH_Matrix_Classes::Integer get_shallowcut() const {return shallowcut;}
  
  const Groundset* get_groundset() const {return groundset;}
  const BundleModel* get_model() const {return model;}
  BundleProxObject* get_prox() const {return Hp;}
  BundleTerminator* get_terminator() const {return terminator;}
  BundleWeight*  get_bundleweight() const {return bundleweight;}

  CH_Tools::Microseconds get_QPcoeff_time() const {return QPcoeff_time;} 
  CH_Tools::Microseconds get_QPsolve_time() const {return QPsolve_time;}
  CH_Tools::Microseconds get_make_aggr_time() const {return make_aggr_time;}
  CH_Tools::Microseconds get_evalaugmodel_time() const {return evalaugmodel_time;}
  std::ostream& print_statistics(std::ostream& out) const;
  int qp_mfile_data(const CH_Matrix_Classes::Matrix& center_y,
                    const BundleProxObject* Hp,
                    const MinorantPointer& gs_subg,
                    const CH_Matrix_Classes::Symmatrix& Q,
                    const CH_Matrix_Classes::Matrix& c,
                    CH_Matrix_Classes::Real offset,
                    const CH_Matrix_Classes::Indexmatrix& yfixed
                    ) const;


};


}

#endif