QPModelBlock.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_QPMODELBLOCK_HXX
#define CONICBUNDLE_QPMODELBLOCK_HXX

#include "QPModelDataObject.hxx"
#include "QPModelBlockObject.hxx"

namespace ConicBundle {



  class QPModelBlock: public virtual QPModelDataObject, public QPModelBlockObject
{
protected:
  std::vector<MinorantPointer> constant_minorant;
  std::vector<MinorantBundle> bundle;

  CH_Matrix_Classes::Matrix modelx;               
  CH_Matrix_Classes::Matrix Bt;                   
  CH_Matrix_Classes::Matrix modeldx;              
  CH_Matrix_Classes::Matrix modeldcstr;           
  CH_Matrix_Classes::Matrix sysviol_model;        
  CH_Matrix_Classes::Matrix sysviol_constraints;  
  
  MinorantPointer modelx_aggregate; 

  virtual void modelx_changed()
  {
    modelx.init(0,1,0.);

    modeldx.init(0,0,0.);
    modeldcstr.init(0,0,0.);
    sysviol_model.init(0,0,0.);
    sysviol_constraints.init(0,0,0.);
  }

public:

  void clear()
  { constant_minorant.clear(); bundle.clear();modelx_aggregate.clear();
    modelx_changed();Bt.init(0,0,0.);}

  QPModelBlock(CBout* cb=0,int cbinc=-1):QPModelDataObject(cb,cbinc),QPModelBlockObject()
  {}

  virtual ~QPModelBlock();

  virtual void recursive_delete_and_clear()=0;

  virtual QPModelBlockObject* clone()=0;

  virtual const MinorantPointer& get_constant_minorant() const
  { return constant_minorant.back(); }
  
  virtual const MinorantBundle& get_bundle() const
  { return bundle.back();}  

  virtual MinorantPointer& get_constant_minorant() 
  { return constant_minorant.back(); }
  
  virtual MinorantBundle& get_bundle() 
  { return bundle.back();}  

  virtual int push_aft(const AffineFunctionTransformation* inaft,
                        const CH_Matrix_Classes::Indexmatrix* global_indices,
                        const CH_Matrix_Classes::Indexmatrix* local_indices,
                        std::map<MinorantPointer,MinorantPointer>* precomputed=0);

  virtual int pop_aft();

  virtual CH_Matrix_Classes::Integer dim_bundle()
  {return CH_Matrix_Classes::Integer(get_bundle().size());}

  virtual CH_Matrix_Classes::Matrix&
  B_times(const CH_Matrix_Classes::Matrix& A,
          CH_Matrix_Classes::Matrix& C,
          CH_Matrix_Classes::Real alpha,
          CH_Matrix_Classes::Real beta,
          int Btrans,
          int Atrans,
          CH_Matrix_Classes::Integer startindex_model,
          MinorantBundle& globalbundle,
          CH_Matrix_Classes::Integer startindex_bundle)=0;
                                                   
  virtual CH_Matrix_Classes::Matrix&
  times_B(const CH_Matrix_Classes::Matrix& A,
          CH_Matrix_Classes::Matrix& C,
          CH_Matrix_Classes::Real alpha,
          CH_Matrix_Classes::Real beta,
          int Atrans,
          int Btrans,
          CH_Matrix_Classes::Integer startindex_model,
          MinorantBundle& globalbundle,
          CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual CH_Matrix_Classes::Symmatrix&
  add_BDBt(const CH_Matrix_Classes::Matrix& diagvec,
           CH_Matrix_Classes::Symmatrix& bigS,
           bool minus,
           CH_Matrix_Classes::Integer startindex,
           CH_Matrix_Classes::Matrix& Bt,
           CH_Matrix_Classes::Integer startindex_model,
           MinorantBundle& globalbundle,
           CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual CH_Matrix_Classes::Matrix&
  get_Bt(CH_Matrix_Classes::Matrix& Bt,
         CH_Matrix_Classes::Integer startindex_model,
         MinorantBundle& global_bundle,
         CH_Matrix_Classes::Integer startindex_bundle)=0;
  
  virtual int get_modelx(CH_Matrix_Classes::Matrix& modelx,
                         CH_Matrix_Classes::Integer startindex_model)=0;

  virtual int get_modeldx(CH_Matrix_Classes::Matrix& modeldx,
                          CH_Matrix_Classes::Integer startindex_model)=0;

  virtual int get_modeldcstr(CH_Matrix_Classes::Matrix& modeldcstr,
                             CH_Matrix_Classes::Integer startindex_constraints)=0;

  virtual int add_modelx_aggregate(CH_Matrix_Classes::Real& val,
                                   CH_Matrix_Classes::Matrix& vec,
                                   MinorantBundle& global_bundle,
                                   CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int get_sysviol_model(CH_Matrix_Classes::Matrix& modelvec,
                                CH_Matrix_Classes::Integer startindex_model,
                                const CH_Matrix_Classes::Matrix& dy,
                                MinorantBundle& global_bundle,
                                CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int get_sysviol_constraints(CH_Matrix_Classes::Matrix& constrvec,
                                      CH_Matrix_Classes::Integer startindex_constr)=0;

  virtual int reset_starting_point(const CH_Matrix_Classes::Matrix& y,
                                   CH_Matrix_Classes::Real mu,
                                   MinorantBundle& global_bundle,
                                   CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int compute_step(const CH_Matrix_Classes::Matrix& ystep,
                           MinorantBundle& global_bundle,
                           CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int computed_step(const CH_Matrix_Classes::Matrix& modelxstep,
                            CH_Matrix_Classes::Integer startindex_model,
                            const CH_Matrix_Classes::Matrix& modelconstrstep,
                            CH_Matrix_Classes::Integer startindex_constr)=0;

  virtual int do_step(CH_Matrix_Classes::Real alpha,
                      const CH_Matrix_Classes::Matrix& y,
                      MinorantBundle& global_bundle,
                      CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int add_localrhs(CH_Matrix_Classes::Matrix& globalrhs, 
                           CH_Matrix_Classes::Real rhsmu,
                           CH_Matrix_Classes::Real rhscorr,
                           CH_Matrix_Classes::Integer startindex_model,
                           CH_Matrix_Classes::Integer startindex_constraints,
                           bool append,
                           MinorantBundle& bundle,
                           CH_Matrix_Classes::Integer startindex_bundle) =0;

  virtual int add_BtinvsysB(CH_Matrix_Classes::Symmatrix& globalsys,
                            MinorantBundle& bundle,
                            CH_Matrix_Classes::Integer startindex_bundle) =0;

  virtual int solve_constrsys(const CH_Matrix_Classes::Symmatrix& ABchol,
                              const CH_Matrix_Classes::Matrix& LinvABrhs,
                              CH_Matrix_Classes::Matrix& LinvABsol,
                              CH_Matrix_Classes::Integer startindex_model,
                              CH_Matrix_Classes::Matrix& Crhs_and_sol,
                              CH_Matrix_Classes::Integer startindex_constraints) =0;


  virtual int add_BCSchur_diagonal(CH_Matrix_Classes::Matrix& diagonal,
                                   MinorantBundle& globalbundle,
                                   CH_Matrix_Classes::Integer startindex_bundle)=0;


  virtual int propose_BCSchur_pcsubspace(CH_Matrix_Classes::Matrix& lowrank,
                                         CH_Matrix_Classes::Matrix& sigma_guess,
                                         const CH_Matrix_Classes::Matrix& Diag_inv,
                                         CH_Matrix_Classes::Real minval,
                                         CH_Matrix_Classes::Real diaginvval,
                                         MinorantBundle& globalbundle,
                                         CH_Matrix_Classes::Integer startindex_bundle)=0;


  virtual int prepare_BCSchur_JLprecond(CH_Matrix_Classes::Matrix& glob_lowrank,
                                        CH_Matrix_Classes::Matrix& subspace,
                                        bool append_globtransp_times_mat_to_subspace,
                                        MinorantBundle& globalbundle,
                                        CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int add_Schur_rhs(CH_Matrix_Classes::Matrix& glob_rhs,
                            CH_Matrix_Classes::Matrix* local_rhs,
                            CH_Matrix_Classes::Real rhsmu,
                            CH_Matrix_Classes::Real rhscorr,
                            CH_Matrix_Classes::Integer startindex_constraints,
                            MinorantBundle& globalbundle,
                            CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int add_Schur_mult(const CH_Matrix_Classes::Matrix& in_vec,
                             CH_Matrix_Classes::Matrix& out_vec,
                             const CH_Matrix_Classes::Matrix* in_cvec,
                             CH_Matrix_Classes::Matrix* out_cvec,
                             CH_Matrix_Classes::Integer startindex_constraints,
                             MinorantBundle& globalbundle,
                             CH_Matrix_Classes::Integer startindex_bundle)=0;

  virtual int computed_Schur_step(const CH_Matrix_Classes::Matrix& xstep,
                                  const CH_Matrix_Classes::Matrix& local_step,
                                  CH_Matrix_Classes::Integer startindex_model,
                                  MinorantBundle& globalbundle,
                                  CH_Matrix_Classes::Integer startindex_bundle)=0;
  
  
  virtual CH_Matrix_Classes::Real globalx_cost(const CH_Matrix_Classes::Matrix& globalx);

  virtual int add_modelx_aggregate(CH_Matrix_Classes::Real& val,
                                   CH_Matrix_Classes::Matrix& vec);

  virtual int add_Bt_modelx(CH_Matrix_Classes::Real& val,
                            CH_Matrix_Classes::Matrix& vec)
  { return add_modelx_aggregate(val,vec); }
  
  virtual CH_Matrix_Classes::Matrix& B_times(const CH_Matrix_Classes::Matrix& A,
                                          CH_Matrix_Classes::Matrix& C,
                                          CH_Matrix_Classes::Real alpha=1.,
                                          CH_Matrix_Classes::Real beta=0.,
                                          int Btrans=0,
                                             int Atrans=0);

   virtual CH_Matrix_Classes::Matrix& times_B(const CH_Matrix_Classes::Matrix& A,
                                              CH_Matrix_Classes::Matrix& C,
                                              CH_Matrix_Classes::Real alpha=1.,
                                              CH_Matrix_Classes::Real beta=0.,
                                              int Atrans=0,
                                              int Btrans=0);   

  virtual CH_Matrix_Classes::Symmatrix& add_BDBt(const CH_Matrix_Classes::Matrix& diagvec,
                                                 CH_Matrix_Classes::Symmatrix& S,
                                                 bool minus=false,
                                                 CH_Matrix_Classes::Integer startindex=0);


  virtual CH_Matrix_Classes::Matrix& get_Bt(CH_Matrix_Classes::Matrix& Bt,
                                            CH_Matrix_Classes::Integer start_col=0);
  
  virtual CH_Matrix_Classes::Matrix& get_x();
 
  virtual CH_Matrix_Classes::Matrix& get_dx();

  virtual CH_Matrix_Classes::Matrix& get_dcstr();

  virtual CH_Matrix_Classes::Matrix& get_sysviol_model(const CH_Matrix_Classes::Matrix& dy);
  
  virtual CH_Matrix_Classes::Matrix& get_sysviol_constraints();  

  virtual void display_model_values(const CH_Matrix_Classes::Matrix& y,
                                    MinorantBundle& global_bundle,
                                    CH_Matrix_Classes::Integer startindex_bundle,
                                    std::ostream& out)=0;

  virtual void display_model_values(const CH_Matrix_Classes::Matrix& y,
                                    std::ostream& out);

  int reset_starting_point(const CH_Matrix_Classes::Matrix& y,CH_Matrix_Classes::Real mu);
   
  int compute_step(const CH_Matrix_Classes::Matrix& ystep);

  int computed_step(const CH_Matrix_Classes::Matrix& modelxstep,
                    const CH_Matrix_Classes::Matrix& modelconstrstep);

  int do_step(CH_Matrix_Classes::Real alpha,const CH_Matrix_Classes::Matrix& nexty);

  int add_localrhs(CH_Matrix_Classes::Matrix& globalrhs,
                   CH_Matrix_Classes::Real rhsmu,
                   CH_Matrix_Classes::Real rhscorr,
                   CH_Matrix_Classes::Integer startindex_model,
                   CH_Matrix_Classes::Integer startindex_constraints,
                   bool append);

  int add_BtinvsysB(CH_Matrix_Classes::Symmatrix& globalsys);

  virtual int solve_constrsys(const CH_Matrix_Classes::Symmatrix& ABchol,
                              CH_Matrix_Classes::Matrix& ABCrhs_and_sol,
                              CH_Matrix_Classes::Integer startindex_model,
                              CH_Matrix_Classes::Integer startindex_constraints);


  virtual int add_BCSchur_diagonal(CH_Matrix_Classes::Matrix& diagonal);


  virtual int propose_BCSchur_pcsubspace(CH_Matrix_Classes::Matrix& lowrank,
                                         CH_Matrix_Classes::Matrix& sigma_guess,
                                         const CH_Matrix_Classes::Matrix& Diag_inv,
                                         CH_Matrix_Classes::Real minval,
                                         CH_Matrix_Classes::Real diaginvval=-1.);

  virtual int prepare_BCSchur_JLprecond(CH_Matrix_Classes::Matrix& glob_lowrank,
                                        CH_Matrix_Classes::Matrix& subspace,
                                        bool append_globtransp_times_mat_to_subspace=false);

  virtual int add_Schur_rhs(CH_Matrix_Classes::Matrix& glob_rhs,
                            CH_Matrix_Classes::Matrix* local_rhs,
                            CH_Matrix_Classes::Real rhsmu,
                            CH_Matrix_Classes::Real rhscorr);

  virtual int add_Schur_mult(const CH_Matrix_Classes::Matrix& in_Qvec,
                             CH_Matrix_Classes::Matrix& out_Qvec,
                             const CH_Matrix_Classes::Matrix* in_Cvec=0,
                             CH_Matrix_Classes::Matrix* out_Cvec=0);

  virtual int computed_Schur_step(const CH_Matrix_Classes::Matrix& xstep,
                                  const CH_Matrix_Classes::Matrix& local_step);
   

};

class QPModelPointer: public virtual QPModelDataPointer
{
protected:
  QPModelBlock* model_block;  
public:
  QPModelPointer(CBout* cb=0,int cbinc=-1):QPModelDataPointer(cb,cbinc),model_block(0){}
  virtual ~QPModelPointer();

  void clear_model_data_ptr()
  {model_block=0;}

  
  int set_model_data(QPModelDataObject* inbp)
  { model_block=dynamic_cast<QPModelBlock*>(inbp); return (model_block==0);}

  QPSumModelDataObject* generate_summodel_data(BundleModel* bmp=0);
 
  QPConeModelDataObject* generate_conemodel_data(BundleModel* bmp=0);
  
  QPModelDataObject* get_model_data_ptr() const {return model_block;}
};

  

}

#endif