PSCIPBundleBlock.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_PSCIPBUNDLEBLOCK_HXX
#define CONICBUNDLE_PSCIPBUNDLEBLOCK_HXX

#include "InteriorPointBundleBlock.hxx"
#include "PSCIPBlock.hxx"
#include "SparseCoeffmatMatrix.hxx"

namespace ConicBundle {


  class QPPSCOracleDataObject: public QPModelOracleDataObject
  {
  public:
    virtual ~QPPSCOracleDataObject();
    
    virtual const SparseCoeffmatMatrix& get_opAt()=0;
    
    virtual const SparseCoeffmatMatrix& get_C()=0;

    virtual const CH_Matrix_Classes::Matrix& get_bundlevecs()=0;
    
  };

  class PSCIPBundleBlock: public InteriorPointBundleBlock, public PSCIPBlock
{
private:
  CH_Matrix_Classes::Matrix B;       
  CH_Matrix_Classes::Matrix Boffset; 
  CH_Matrix_Classes::Matrix sqrBnorms; 
  CH_Matrix_Classes::Indexmatrix Bnzcolind; 

  QPPSCOracleDataObject* oracle_data; 
  
  CH_Matrix_Classes::Matrix testmat; 


  CH_Matrix_Classes::Integer active_rank(const CH_Matrix_Classes::Matrix& lamX,
                                         const CH_Matrix_Classes::Matrix& vecX,
                                         CH_Matrix_Classes::Real trace_bound,
                                         bool cautious) const;
  
  int get_growth(const CH_Matrix_Classes::Matrix& lamX,
                 const CH_Matrix_Classes::Matrix& vecX,
                 CH_Matrix_Classes::Real& growthrate,
                 CH_Matrix_Classes::Matrix& primalgrowth,
                 CH_Matrix_Classes::Matrix& dualgrowth) const;

  int form_B(CH_Matrix_Classes::Integer dim,
             const MinorantBundle& globalbundle,
             CH_Matrix_Classes::Integer startindex_bundle);
  
  int sveciB_times_vec(const CH_Matrix_Classes::Matrix& vec,
                       CH_Matrix_Classes::Matrix& Bvec);
  
public:
  void clear(CH_Matrix_Classes::Integer dim=0);
  
  PSCIPBundleBlock(CH_Matrix_Classes::Integer dim=0, CBout* cb=0,int cbinc=-1);

  ~PSCIPBundleBlock();

  virtual InteriorPointBundleBlock* clone();
    
  virtual int copy_from(InteriorPointBundleBlock*);
  
  virtual void set_oracle_data(QPModelOracleDataObject* in_oracle_data)
  {oracle_data=dynamic_cast<QPPSCOracleDataObject*>(in_oracle_data);}

  virtual CH_Matrix_Classes::Integer dim_bundle() const
  {return bundle_dim;}
  
  virtual CH_Matrix_Classes::Real evaluate_trace_x();

  virtual CH_Matrix_Classes::Real evaluate_trace_z();

  virtual CH_Matrix_Classes::Real evaluate_trace_dx();

  virtual int add_trace(CH_Matrix_Classes::Matrix& vec,
                        CH_Matrix_Classes::Real alpha,
                        CH_Matrix_Classes::Integer startindex);
  
  virtual int set_xizinvsqrt_trace(CH_Matrix_Classes::Matrix& vec,
                                   CH_Matrix_Classes::Integer startindex);
  
  // after the bundle subproblem is solved, this retrieves the local linear solution vector; if linx_activity is set, the values between zero and one indicate the guess on the coefficients activity level 
  // virtual int get_linx(CH_Matrix_Classes::Matrix& linx,
  //                   CH_Matrix_Classes::Matrix* linx_activity=0) const;

  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 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& sysviol_model,
                                CH_Matrix_Classes::Integer startindex_model,
                                const CH_Matrix_Classes::Matrix& dy,
                                const CH_Matrix_Classes::Real deltatrdual,
                                MinorantBundle& global_bundle,
                                CH_Matrix_Classes::Integer startindex_bundle);

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

  virtual int add_trace_to_diff_model(CH_Matrix_Classes::Real trace_dual);

  virtual CH_Matrix_Classes::Real dualviol_2normsqr();

  virtual int do_bundle_step(CH_Matrix_Classes::Real alpha,
                      const CH_Matrix_Classes::Matrix& y,
                      MinorantBundle& globalbundle,
                      CH_Matrix_Classes::Integer startindex_bundle,
                      CH_Matrix_Classes::Real tracedual,
                      CH_Matrix_Classes::Real trace_rhs);

  virtual int set_modelrhs(CH_Matrix_Classes::Matrix& globalrhs, 
                           CH_Matrix_Classes::Real rhsmu,
                           CH_Matrix_Classes::Real rhscorr,
                           CH_Matrix_Classes::Integer startindex_model);

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

  int Schur_transform_bundle(CH_Matrix_Classes::Matrix& glob_lowrank,
                             MinorantBundle& globalbundle,
                             CH_Matrix_Classes::Integer startindex_bundle,
                             CH_Matrix_Classes::Matrix& trafotrace,
                             CH_Matrix_Classes::Integer startindex_trace);
  

  virtual int add_bundle_xizinv_diagonal(CH_Matrix_Classes::Matrix& diagonal,
                                         CH_Matrix_Classes::Matrix& ipBtrvec,
                                         MinorantBundle& globalbundle,
                                         CH_Matrix_Classes::Integer startindex_bundle,
                                         const CH_Matrix_Classes::Matrix& trafotrace,
                                         CH_Matrix_Classes::Integer startindex_trace);
                                         


  virtual int add_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,
                             CH_Matrix_Classes::Matrix & minus_trmult,
                             CH_Matrix_Classes::Real schur_trace,
                             MinorantBundle& globalbundle,
                             CH_Matrix_Classes::Integer startindex_bundle);


  int add_bundle_xizinvsqrt_projection(CH_Matrix_Classes::Matrix& glob_lowrank,
                                       CH_Matrix_Classes::Matrix& subspace,
                                       CH_Matrix_Classes::Integer startindex_subsspace,
                                       MinorantBundle& globalbundle,
                                       CH_Matrix_Classes::Integer startindex_bundle);

  virtual int add_BtinvsysB_times(const CH_Matrix_Classes::Matrix& in_vec,
                                  CH_Matrix_Classes::Matrix& out_vec,
                                  CH_Matrix_Classes::Real zeta_inval,
                                  CH_Matrix_Classes::Real* zeta_outval,
                                  MinorantBundle& globalbundle,
                                  CH_Matrix_Classes::Integer startindex_bundle);

  virtual int set_dx_xizsolvestep(const CH_Matrix_Classes::Matrix& step_y,
                                 const CH_Matrix_Classes::Real step_trdual,
                                 MinorantBundle& globalbundle,
                                 CH_Matrix_Classes::Integer startindex_bundle);
                                  

  int get_pscx(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);

   
};

  

}

#endif