SOCIPBundleBlock.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SOCIPBUNDLEBLOCK_HXX
#define CONICBUNDLE_SOCIPBUNDLEBLOCK_HXX

#include "InteriorPointBundleBlock.hxx"
#include "SOCIPBlock.hxx"

namespace ConicBundle {


  class SOCIPBundleBlock: public InteriorPointBundleBlock, public SOCIPBlock
{
private:
  CH_Matrix_Classes::Matrix Bt;       
  CH_Matrix_Classes::Matrix Boffset; 
  CH_Matrix_Classes::Matrix sqrBnorms; 

public:
  void clear(CH_Matrix_Classes::Integer dim=0);
  
  SOCIPBundleBlock(CH_Matrix_Classes::Integer dim=0, CBout* cb=0,int cbinc=-1);

  ~SOCIPBundleBlock();

  virtual InteriorPointBundleBlock* clone();
    
  virtual int copy_from(InteriorPointBundleBlock*);
  
  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);
                                  
  virtual int get_socx(CH_Matrix_Classes::Matrix& socx,
                       CH_Matrix_Classes::Real* socx_activity,
                       CH_Matrix_Classes::Real trace_rhs,
                       bool cautious) const;


   
};

  

}

#endif