InteriorPointBundleBlock.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_INTERIORPOINTBUNDLEBLOCK_HXX
#define CONICBUNDLE_INTERIORPOINTBUNDLEBLOCK_HXX

#include "InteriorPointBlock.hxx"
#include "MinorantPointer.hxx"
#include "QPModelDataObject.hxx"

namespace ConicBundle {
  

class InteriorPointBundleBlock: public virtual InteriorPointBlock
{
protected:
  CH_Matrix_Classes::Integer bundle_dim;   
  CH_Matrix_Classes::Matrix diff_model;  

public:
  InteriorPointBundleBlock(CBout* cb=0,int cbinc=-1):CBout(cb,cbinc){bundle_dim=0;}

  virtual ~InteriorPointBundleBlock(); 
  
  virtual InteriorPointBundleBlock* clone()=0;
  
  virtual int copy_from(InteriorPointBundleBlock*)=0;
  
  //virtual CH_Matrix_Classes::Integer get_vecdim() const =0;

  virtual void set_oracle_data(QPModelOracleDataObject* /*oracle_data*/)
  {}

  virtual CH_Matrix_Classes::Integer dim_bundle() const=0;

  virtual CH_Matrix_Classes::Real evaluate_trace_x() =0;

  virtual CH_Matrix_Classes::Real evaluate_trace_z() =0;

  virtual CH_Matrix_Classes::Real evaluate_trace_dx() =0;

  virtual int add_trace(CH_Matrix_Classes::Matrix& vec,
                        CH_Matrix_Classes::Real alpha,
                        CH_Matrix_Classes::Integer startindex) =0;

  virtual int set_xizinvsqrt_trace(CH_Matrix_Classes::Matrix& vec,
                                   CH_Matrix_Classes::Integer startindex) =0;
  
  // set x to value*"one" to x, or if add==true, add value*"one" to x
  //virtual int center_x(CH_Matrix_Classes::Real val,bool add=false)=0;

  // set z to value*"one" to z, or if add==true, add value*"one" to z
  //virtual int center_z(CH_Matrix_Classes::Real val,bool add=false)=0;

  // set x to the values of vec[startindex+0,+1 ...,+(vecdim-1)] and return in add_center_value a value>=0 that needs to be added to make it feasible
  //virtual int set_x(const CH_Matrix_Classes::Matrix& vec,
  //                CH_Matrix_Classes::Integer startindex,
  //                CH_Matrix_Classes::Real& add_center_value)=0;

  // set z to the values of vec[startindex+0,+1 ...,+(vecdim-1)] and return a value>=0 that needs to be added to make it feasible
  //virtual int set_z(const CH_Matrix_Classes::Matrix& vec,
  //                CH_Matrix_Classes::Integer startindex,
  //                CH_Matrix_Classes::Real& add_center_value)=0;

  // on vec[startindex+0,+1 ...,+(vecdim-1)] put or add  a * x into vec for a real number a  
  //virtual int vecgetsax(CH_Matrix_Classes::Matrix& vec,
  //                    CH_Matrix_Classes::Integer startindex,
  //                    CH_Matrix_Classes::Real a=1.,
  //                    bool add=false)=0;

  // on vec[startindex+0,+1 ...,+(vecdim-1)] put or add a * z into vec for a real number a   
  //virtual int vecgetsaz(CH_Matrix_Classes::Matrix& vec,
  //                    CH_Matrix_Classes::Integer startindex,
  //                    CH_Matrix_Classes::Real a=1.,
  //                    bool add=false)=0;

  // add dimensions of the primal-dual pairs to mudim and add the inner products of the primal-dual pairs of the current point to current_ip and those of the next point obtained by the given stepsize with the latest computed step to step_ip
  //virtual int get_mu_info(CH_Matrix_Classes::Integer& inmudim,
  //              CH_Matrix_Classes::Real& current_ip,
  //              CH_Matrix_Classes::Real& step_ip,
  //              CH_Matrix_Classes::Real stepsize) const =0;

  // if necessary, reduce alpha to the biggest value so that feasibility is maintained with this step size
  //virtual int linesearch(CH_Matrix_Classes::Real& alpha) const=0;

  // compute the complementarity_rhs=rhsmu*xi-rhscorr*xi*dx*dz (wihtout "-z") for mu=rhsmu and for corrector for factor rhscorr>0., store this and add it to rhs;
  //virtual int add_muxinv(CH_Matrix_Classes::Matrix& rhs,
  //                     CH_Matrix_Classes::Integer startindex,
  //                     CH_Matrix_Classes::Real rhsmu,
  //                     CH_Matrix_Classes::Real rhscorr,
  //                     bool minus=false)=0;

  //virtual int set_dx(const CH_Matrix_Classes::Matrix& rhs,CH_Matrix_Classes::Integer startindex)=0;

  // compute dx=sysinv*rhs and at the same time dz (=-rhs-z +complentarity_rhs); may only be called after add_muxinv was called for the most recent point; this may only be called after add_muxinv() was called for this point
  //virtual int set_dx_xizsolverhs(const CH_Matrix_Classes::Matrix& rhs,
  //                            CH_Matrix_Classes::Integer startindex)=0;

  // compute sysinv*rhs into rhs, possibly with a negative sign 
  //virtual int apply_xizinv(CH_Matrix_Classes::Matrix& rhs,
  //                       CH_Matrix_Classes::Integer startindex,
  //                       bool minus=false)=0;

  // compute sys*rhs into rhs, possibly with a negative sign
  //virtual int apply_xiz(CH_Matrix_Classes::Matrix& rhs,
  //                    CH_Matrix_Classes::Integer startindex,
  //                    bool minus=false)=0;

  // move to (x+alpha*dx, z+alpha*dz)
  //virtual int do_step(CH_Matrix_Classes::Real alpha)=0;
  //

  // add the Schur complement to a big system matrix
  //virtual int add_AxizinvAt(const CH_Matrix_Classes::Matrix& A,
  //                        CH_Matrix_Classes::Symmatrix& globalsys,
  //                        bool minus=false)=0;

  //add (or subract if minus==true) the system matrix to a big system matrix starting at startindex
  //virtual int add_xiz(CH_Matrix_Classes::Symmatrix& globalsys,
  //                  CH_Matrix_Classes::Integer startindex,
  //                  bool minus=false)=0;

  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 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& 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)=0;

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

  virtual int add_trace_to_diff_model(CH_Matrix_Classes::Real trace_dual)=0;

  virtual CH_Matrix_Classes::Real dualviol_2normsqr()=0;

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

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

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

  virtual 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)=0;


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


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

  virtual 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) =0;


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

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

  
  //---------------------- mainly for testing

  // return the vector form of x 
  //virtual int get_vecx(CH_Matrix_Classes::Matrix& vecx,CH_Matrix_Classes::Integer startindex)=0;
  
  // return the vector form of z
  //virtual int get_vecz(CH_Matrix_Classes::Matrix& vecz,CH_Matrix_Classes::Integer startindex)=0;
  
  // return the vector form of dx, 1 if not available 
  //virtual int get_vecdx(CH_Matrix_Classes::Matrix& vecdx,CH_Matrix_Classes::Integer startindex)=0;
  
  // return the vector form of dz, 1 if not available
  // virtual int get_vecdz(CH_Matrix_Classes::Matrix& vecdz,CH_Matrix_Classes::Integer startindex)=0;
  

};

  



}

#endif