QPConeModelBlock.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_QPCONEMODELBLOCK_HXX
#define CONICBUNDLE_QPCONEMODELBLOCK_HXX

#include "QPModelBlock.hxx"
#include "NNCIPBundleBlock.hxx"
#include "SOCIPBundleBlock.hxx"
#include "PSCIPBundleBlock.hxx"
#include "BoxIPBundleBlock.hxx"

namespace ConicBundle {



  class QPConeModelBlock: public QPModelBlock, public QPConeModelDataObject
{
private:
  //data that stays constant after init
  CH_Matrix_Classes::Integer modeldim; 
  CH_Matrix_Classes::Integer mu_dim; 
  FunctionTask ft; 
  bool use_trace;   

  //values related to the barrier parameter
  CH_Matrix_Classes::Real last_rhs_mu;  
  CH_Matrix_Classes::Real mu;           
  CH_Matrix_Classes::Real old_mu;       

  // primal-dual variables for the trace constraint
  CH_Matrix_Classes::Matrix trace_vec;  
  CH_Matrix_Classes::Real trace_rhs; 
  CH_Matrix_Classes::Real trace_slack;  
  CH_Matrix_Classes::Real trace_dual;  

  CH_Matrix_Classes::Real trace_delta_slack; 
  CH_Matrix_Classes::Real trace_delta_dual; 

  CH_Matrix_Classes::Real sys_trace;   
  CH_Matrix_Classes::Real complrhs_trace;  

  // data that stays fixed as long as the working point is not changed
  CH_Matrix_Classes::Matrix diff_model;  
  CH_Matrix_Classes::Real diff_trace;    

  // data that records the rhs used depending on predictor/corrector settings 
  CH_Matrix_Classes::Matrix sysrhs_model; 
  CH_Matrix_Classes::Real sysrhs_trace; 
  CH_Matrix_Classes::Matrix sysinv_trace;   
  CH_Matrix_Classes::Matrix Btsysinv_trace;   
  CH_Matrix_Classes::Real schur_trace;   

  // basic interior point blocks for the cones
  NNCIPBundleBlock* nncblock; 
  std::vector<SOCIPBundleBlock*> socblock; 
  std::vector<PSCIPBundleBlock*> pscblock; 
  BoxIPBundleBlock* boxblock; 

  std::vector<InteriorPointBundleBlock*> block; 

  QPModelOracleDataObject* oracle_data; 


  CH_Matrix_Classes::Real evaluate_trace(CH_Matrix_Classes::Matrix& vec);

  void modelx_changed();

public:

  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);
                                                   
  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);

  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);

  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);
  
  virtual int get_modelx(CH_Matrix_Classes::Matrix& modelx,
                         CH_Matrix_Classes::Integer startindex_model);

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

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

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

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

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

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

  // bundlevalues holds the negative evaluation of the bundle for the current y 
  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);

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

  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);

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

  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_bundel);

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

  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);


  
public:
  void clear();

  QPConeModelBlock(CBout* cb=0,int cbinc=-1);

  virtual ~QPConeModelBlock();

  virtual QPModelBlockObject* clone();

  virtual void recursive_delete_and_clear();

  virtual int recursive_copy_data_of(QPModelBlockObject*);

  //------------ QPModelBlockObject routines

  int init(const MinorantPointer& constant_minorant,
           const MinorantBundle& bundle,
           CH_Matrix_Classes::Integer nnc_dim,
           const CH_Matrix_Classes::Indexmatrix& soc_dim,
           const CH_Matrix_Classes::Indexmatrix& psc_dim,
           const CH_Matrix_Classes::Matrix& box_lb,
           const CH_Matrix_Classes::Matrix& box_ub,
           CH_Matrix_Classes::Real b,
           FunctionTask ft,
           QPModelOracleDataObject* oracle_data=0,
           bool scale_box=true); 

  int adjust_trace(CH_Matrix_Classes::Real b);
    

  CH_Matrix_Classes::Real evaluate_trace() const; 

  CH_Matrix_Classes::Real get_trace();

  int get_nncx(CH_Matrix_Classes::Matrix& nncx,
               CH_Matrix_Classes::Matrix* nncx_activity=0,
               bool cautious=false);

  int get_socx(CH_Matrix_Classes::Integer i,
               CH_Matrix_Classes::Matrix& socx,
               CH_Matrix_Classes::Real* socx_activity,
               bool cautious=false);
  
  int get_pscx(CH_Matrix_Classes::Integer i,
               CH_Matrix_Classes::Matrix& pscx_eigs,
               CH_Matrix_Classes::Matrix& pscx_vecs,
               CH_Matrix_Classes::Real& pscx_growthrate,
               CH_Matrix_Classes::Matrix& pscx_primalgrowth,
               CH_Matrix_Classes::Matrix& pscx_dualgrowth);

  int get_boxx(CH_Matrix_Classes::Matrix& boxx,
               CH_Matrix_Classes::Matrix* linx_activity=0,
               bool cautious=false);

  CH_Matrix_Classes::Real tracedual(CH_Matrix_Classes::Real* prec=0) const;
  

  //-----------  QPBlock routines

  virtual CH_Matrix_Classes::Integer dim_model();

  virtual CH_Matrix_Classes::Integer dim_constraints();

  virtual CH_Matrix_Classes::Real constraints_cost();
      
  virtual CH_Matrix_Classes::Real primalviol_2normsqr();
   
  virtual CH_Matrix_Classes::Real dualviol_2normsqr();
    
  virtual int get_mu_info(CH_Matrix_Classes::Integer& mudim,
                          CH_Matrix_Classes::Real& tr_xz,
                          CH_Matrix_Classes::Real& tr_xdzpdxz,
                          CH_Matrix_Classes::Real& tr_dxdz,
                          CH_Matrix_Classes::Real& min_xz,
                          CH_Matrix_Classes::Real& max_xz) const;

  virtual int get_nbh_info(CH_Matrix_Classes::Integer mudim,
                           CH_Matrix_Classes::Real tr_xz,
                           CH_Matrix_Classes::Real tr_xdzpdxz,
                           CH_Matrix_Classes::Real tr_dxdz,
                           CH_Matrix_Classes::Real nbh_ubnd,
                           CH_Matrix_Classes::Real& alpha,
                           CH_Matrix_Classes::Real& max_nbh,
                           CH_Matrix_Classes::Real& nrmsqr_xz,
                           CH_Matrix_Classes::Real& nrmsqr_xdzpdxz,
                           CH_Matrix_Classes::Real& nrmsqr_dxdz,
                           CH_Matrix_Classes::Real& ip_xz_xdzpdxz,
                           CH_Matrix_Classes::Real& ip_xz_dxdz,
                           CH_Matrix_Classes::Real& ip_dxdz_xdzpdxz) const;

  virtual int linesearch(CH_Matrix_Classes::Real& alpha) const;

  virtual int add_localsys(CH_Matrix_Classes::Symmatrix& globalsys,
                           CH_Matrix_Classes::Integer startindex_model,
                           CH_Matrix_Classes::Integer startindex_constraints);  
  
  virtual int localsys_mult(const CH_Matrix_Classes::Matrix& in_vec,
                            CH_Matrix_Classes::Matrix& out_vec,
                            CH_Matrix_Classes::Integer startindex_model,
                            CH_Matrix_Classes::Integer startindex_constraints);
  
  virtual int add_BCSchur_diagonal(CH_Matrix_Classes::Matrix& diagonal,
                                   MinorantBundle& globalbundle,
                                   CH_Matrix_Classes::Integer startindex_bundle);

  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);

  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);
  

  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);

  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);

  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);
  
  void set_cbout(const CBout* cb, int incr=-1)
  {
    CBout::set_cbout(cb,incr);
    for(unsigned int i=0;i<block.size();i++)
      block[i]->set_cbout(this);
  }


  
};



}

#endif