LPGroundset.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_LPGROUNDSET_HXX
#define CONICBUNDLE_LPGROUNDSET_HXX


#include "Groundset.hxx"
#include "QPSolver.hxx"
#include "UQPSolver.hxx"

namespace ConicBundle {

class LPGroundset:public Groundset
{
private:
  CH_Matrix_Classes::Integer dim;  

  CH_Matrix_Classes::Integer groundset_id;

  CH_Matrix_Classes::Matrix starting_point;

  MinorantPointer gs_aggregate;

  bool use_yfixing;                       

  CH_Matrix_Classes::Indexmatrix yfixed;

  //the QPSolver for solving the bundle subproblem with Groundset
  QPSolverObject* qpsolver;   
  UQPSolver uqpsolver;  
  QPSolverObject* qp_solver; 
  bool solve_model_without_gs; 


  //data for describing the QP
  BundleProxObject* Hp;  
  CH_Matrix_Classes::Matrix c; 
  CH_Matrix_Classes::Real gamma; 

  MinorantPointer gs_minorant; 

  //variable metric information

  VariableMetricSelection* vm_selection; 
  
  bool store_old_minorants; 
  MinorantBundle old_minorants; 
  CH_Matrix_Classes::Integer max_minorants; 
  CH_Matrix_Classes::Integer minorant_nexti; 
  CH_Matrix_Classes::Matrix old_lowrank; 
  CH_Matrix_Classes::Matrix old_diagonal; 
  CH_Matrix_Classes::Symmatrix old_sym; 
  
protected:

public:
  virtual void clear( CH_Matrix_Classes::Integer indim=0, 
                      CH_Matrix_Classes::Integer in_groundset_id=0);

  LPGroundset(CBout* cb=0):CBout(cb),vm_selection(0){qpsolver=new QPSolver(cb); uqpsolver.set_cbout(cb); clear(0,0);}

  LPGroundset(CH_Matrix_Classes::Integer dim,
              const CH_Matrix_Classes::Matrix* lbyp=0,
              const CH_Matrix_Classes::Matrix* ubyp=0,
              const CH_Matrix_Classes::Sparsemat* Gp=0,
              const CH_Matrix_Classes::Matrix* rhslbp=0,
              const CH_Matrix_Classes::Matrix* rhsubp=0,
              const CH_Matrix_Classes::Matrix* start_val=0,
              const CH_Matrix_Classes::Matrix* costs=0,
              const CH_Matrix_Classes::Real offset=0., 
              CH_Matrix_Classes::Integer in_groundset_id=0,
              CBout* cb=0);
  
  ~LPGroundset(){delete qpsolver; delete vm_selection;}

  CH_Matrix_Classes::Integer get_groundset_id() const {return groundset_id;}

  void set_groundset_id(CH_Matrix_Classes::Integer gsid){groundset_id=gsid;}

  virtual CH_Matrix_Classes::Integer get_dim() const 
  {return dim;}

  int set_qpsolver(QPSolverParametersObject* qpparams,QPSolverObject* qpsolver=0);

  bool constrained() const
  {return qpsolver->QPconstrained();}

  //CH_Matrix_Classes::Integer rowdim() const {return qpsolver.rowdim();}

  const CH_Matrix_Classes::Matrix* get_lby() const;

  const CH_Matrix_Classes::Matrix* get_uby() const;

  //const CH_Matrix_Classes::Indexmatrix& get_lbindex() const { return qpsolver.get_lbindex();}

  //const CH_Matrix_Classes::Indexmatrix& get_ubindex() const { return qpsolver.get_ubindex();}

  //const CH_Matrix_Classes::Sparsemat& get_G() const { return qpsolver.get_A();}

  //const CH_Matrix_Classes::Matrix& get_rhslb() const {return qpsolver.get_rhslb();}

  //const CH_Matrix_Classes::Matrix& get_rhsub() const {return qpsolver.get_rhsub();}

  //const CH_Matrix_Classes::Indexmatrix& get_rhslbind() const {return qpsolver.get_rhslbind();}

  //const CH_Matrix_Classes::Indexmatrix& get_rhsubind() const {return qpsolver.get_rhsubind();}

  virtual bool is_feasible(CH_Matrix_Classes::Integer& in_groundset_id,
                           const CH_Matrix_Classes::Matrix& y,
                           CH_Matrix_Classes::Real relprec=1e-10);

  int ensure_feasibility(CH_Matrix_Classes::Integer& in_groundset_id,
                         CH_Matrix_Classes::Matrix& y,
                         bool& ychanged,
                         BundleProxObject* Hp,
                         CH_Matrix_Classes::Real relprec=1e-10);

  virtual QPSolverObject* get_qp_solver(bool& solves_model_without_gs,
                                        BundleProxObject* Hp); 

  int set_qp_solver_parameters(QPSolverParametersObject* /* in_qpsp */)
  {
    return 0;
  }

  virtual const CH_Matrix_Classes::Matrix& get_starting_point() const 
  {return starting_point;}

  virtual int set_starting_point(const CH_Matrix_Classes::Matrix& vec)
  {starting_point=vec; int dummy=-1; return (is_feasible(dummy,vec)==false);}

  virtual int candidate(CH_Matrix_Classes::Integer& gs_id,
                        CH_Matrix_Classes::Matrix& newy,
                        CH_Matrix_Classes::Real& cand_gs_val,
                        CH_Matrix_Classes::Real& linval,
                        CH_Matrix_Classes::Real& augval_lb,
                        CH_Matrix_Classes::Real& augval_ub,
                        CH_Matrix_Classes::Real& subgnorm2,
                        const CH_Matrix_Classes::Matrix& center_y,
                        CH_Matrix_Classes::Real center_value,
                        const MinorantPointer& model_minorant,
                        BundleProxObject* Hp,
                        MinorantPointer* delta_groundset_minorant=0,
                        CH_Matrix_Classes::Indexmatrix* delta_index=0,
                        CH_Matrix_Classes::Real relprec=1e-2);
  
  virtual const MinorantPointer& get_gs_aggregate() const { return gs_aggregate;}

  const MinorantPointer& get_gs_minorant() const { return gs_minorant;}

  virtual const CH_Matrix_Classes::Indexmatrix* get_yfixed() const
  {return (use_yfixing? &yfixed : 0);}

  virtual CH_Matrix_Classes::Indexmatrix* set_yfixed()
  {return (use_yfixing? &yfixed : 0);}

  bool get_use_yfixing() const {return use_yfixing;}

  void set_use_yfixing(bool uyf) {use_yfixing=uyf;}

  int set_variable_metric_selection(VariableMetricSelection* vms=0)
  { delete vm_selection; vm_selection=vms; return 0;}

  VariableMetricSelection* get_variable_metric_selection() const
  { return vm_selection;}

  int add_variable_metric(VariableMetric& H,
                          CH_Matrix_Classes::Integer y_id,
                          const CH_Matrix_Classes::Matrix& y,
                          bool descent_step,
                          CH_Matrix_Classes::Real weightu,
                          CH_Matrix_Classes::Real model_maxviol,
                          const CH_Matrix_Classes::Indexmatrix* indices=0);

  GroundsetModification* start_modification()
  { return qpsolver->QPstart_modification();}

  int apply_modification(const GroundsetModification& mdf);


  int mfile_data(std::ostream& out) const;

  void set_cbout(const CBout* cb, int incr=-1)
  {
    VariableMetricModel::set_cbout(cb,incr);
    qpsolver->set_cbout(this);
    uqpsolver.set_cbout(this);
  }

};

}

#endif