BundleLowRankTrustRegionProx.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_LOWRANKTRUSTREGIONPROX_HXX
#define CONICBUNDLE_LOWRANKTRUSTREGIONPROX_HXX


#include "BundleProxObject.hxx"

namespace ConicBundle {


class BundleLowRankTrustRegionProx: public BundleProxObject
{
private:
  CH_Matrix_Classes::Real weightu;

  CH_Matrix_Classes::Matrix vecH;

  CH_Matrix_Classes::Matrix lamH;

  mutable CH_Matrix_Classes::Matrix scaled_vecH;

  mutable CH_Matrix_Classes::Matrix lamHi;
  
  mutable CH_Matrix_Classes::Matrix sqrtlamHi;
  
  CH_Matrix_Classes::Real corr_val;

  CH_Matrix_Classes::Indexmatrix old_fixed_ind;
  CH_Matrix_Classes::Matrix _A;
  CH_Matrix_Classes::Matrix _b; 
  CH_Matrix_Classes::Matrix _c;
  CH_Matrix_Classes::Real _delta;
  CH_Matrix_Classes::Matrix _y;
  CH_Matrix_Classes::Matrix LinvindHt;
  CH_Matrix_Classes::Symmatrix old_LinvQ;
  CH_Matrix_Classes::Matrix oldd;
  CH_Matrix_Classes::Real oldoffset;
 
  const CH_Matrix_Classes::Indexmatrix* new_indices;

  std::vector<const AffineFunctionTransformation*> aft_stack;

  bool needs_cleaning;

  CH_Matrix_Classes::Integer max_columns;

  void clean();

  void compute_corr()
  //{ corr_val=sum(lamH); if ((vecH.rowdim()>0)&&(corr_val>vecH.rowdim())) corr_val=vecH.rowdim()/corr_val; else corr_val=1.;}
  { corr_val=CH_Matrix_Classes::min(1.,vecH.rowdim()/(weightu*vecH.rowdim()+sum(lamH)));}

public:
  BundleLowRankTrustRegionProx(CH_Matrix_Classes::Integer dim=0,
                               VariableMetricSelection* vp=0,
                               bool local_metric=false,
                               CBout* cb=0,int inc=-1):
    BundleProxObject(vp,local_metric,false,cb,inc),
    weightu(1.),vecH(dim,0,0.),lamH(0,1,0.)
  {
    assert(dim>=0);
  }

  BundleLowRankTrustRegionProx(const CH_Matrix_Classes::Matrix& in_vecH,
                               const CH_Matrix_Classes::Matrix& in_lamH,
                               VariableMetricSelection* vp=0,
                               bool local_metric=false,
                               CBout* cb=0,int inc=-1):
    BundleProxObject(vp,local_metric,false,cb,inc)
  {
    weightu=1.;
    init(in_vecH,in_lamH);
  }

  virtual ~BundleLowRankTrustRegionProx(){}

  void set_weightu(CH_Matrix_Classes::Real in_weightu);

  CH_Matrix_Classes::Real get_weightu() const
  {return weightu;}

  CH_Matrix_Classes::Real get_term_corr() const
  {return corr_val;}
  
  void init(const CH_Matrix_Classes::Matrix& in_vecH, 
            const CH_Matrix_Classes::Matrix& in_lamH);

  virtual CH_Matrix_Classes::Real norm_sqr(const CH_Matrix_Classes::Matrix& B) const;

  virtual CH_Matrix_Classes::Real dnorm_sqr(const MinorantPointer& B) const;

  virtual bool is_DLR() const
  {return true;}

  virtual int add_H(CH_Matrix_Classes::Symmatrix& big_sym,CH_Matrix_Classes::Integer start_index=0) const;

  virtual CH_Matrix_Classes::Matrix& add_Hx(const CH_Matrix_Classes::Matrix& x,
                                            CH_Matrix_Classes::Matrix& outplusHx,
                                            CH_Matrix_Classes::Real alpha=1.) const;

  virtual CH_Matrix_Classes::Matrix& apply_Hinv(CH_Matrix_Classes::Matrix& x) const ;

  virtual void get_precond(CH_Matrix_Classes::Matrix& inD,const CH_Matrix_Classes::Matrix*& Vp) const;

  virtual int compute_QP_costs(CH_Matrix_Classes::Symmatrix& Q,
                               CH_Matrix_Classes::Matrix& d,
                               CH_Matrix_Classes::Real& offset,
                               const MinorantPointer& constant_minorant,
                               const MinorantBundle& bundle, 
                               const CH_Matrix_Classes::Matrix& y,
                               const MinorantPointer& groundset_minorant,
                               CH_Matrix_Classes::Indexmatrix* yfixed);
  

  virtual int update_QP_costs(CH_Matrix_Classes::Symmatrix& delta_Q, 
                              CH_Matrix_Classes::Matrix& delta_d,  
                              CH_Matrix_Classes::Real& delta_offset,
                              const MinorantPointer& constant_minorant,
                              const MinorantBundle& bundle,
                              const CH_Matrix_Classes::Matrix& center_y,
                              const MinorantPointer& groundset_minorant,
                              const MinorantPointer& delta_groundset_minorant,
                              const CH_Matrix_Classes::Indexmatrix& delta_index,
                              CH_Matrix_Classes::Indexmatrix* yfixed);


  virtual int apply_modification(const GroundsetModification& gsmdf);


  virtual BundleProxObject* projected_clone(const CH_Matrix_Classes::Indexmatrix& indices); 

  virtual bool supports_diagonal_bounds_scaling() const {return false;}
  
  virtual int diagonal_scaling_heuristic_update(const CH_Matrix_Classes::Matrix& /* D_update */)
  {
    return 1;
  }
  
  virtual bool supports_dense_variable_metric() const
  {return false;}

  virtual bool supports_lowrank_variable_metric() const
  {return true;}

  virtual bool supports_diagonal_variable_metric() const
  {return false;}

  virtual int apply_variable_metric(VariableMetricModel* groundset,
                                    VariableMetricModel* model,
                                    const CH_Matrix_Classes::Matrix& aggr,
                                    CH_Matrix_Classes::Integer y_id,
                                    const CH_Matrix_Classes::Matrix& y,
                                    bool descent_step,
                                    CH_Matrix_Classes::Real& current_weight,
                                    CH_Matrix_Classes::Real model_maxviol,
                                    const CH_Matrix_Classes::Indexmatrix* new_indices =0);
  
  virtual int add_variable_metric(CH_Matrix_Classes::Matrix& diagH,
                                  CH_Matrix_Classes::Matrix& vecH);

  virtual int push_aft(const AffineFunctionTransformation* aft)
  { aft_stack.push_back(aft); return 0;}
  
  virtual int pop_aft()
  { 
    aft_stack.pop_back(); 
    return 0;
  }

  virtual int mfile_data(std::ostream& out) const;


};


}

#endif