BundleDenseTrustRegionProx.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_BUNDLEDENSETRUSTREGIONPROX_HXX
#define CONICBUNDLE_BUNDLEDENSETRUSTREGIONPROX_HXX


#include "BundleProxObject.hxx"

namespace ConicBundle {


class BundleDenseTrustRegionProx: public BundleProxObject
{
private:
  CH_Matrix_Classes::Symmatrix H;

  mutable CH_Matrix_Classes::Symmatrix Hchol;

  mutable bool is_factored;
  
  CH_Matrix_Classes::Symmatrix Hind_chol;

  
  CH_Matrix_Classes::Real weightu;

  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 LinvA;
  CH_Matrix_Classes::Matrix Lty;  
  CH_Matrix_Classes::Symmatrix oldQ;
  CH_Matrix_Classes::Matrix oldd;
  CH_Matrix_Classes::Real oldoffset;


  const CH_Matrix_Classes::Indexmatrix* new_indices;

  std::vector<const AffineFunctionTransformation*> aft_stack;

  void compute_corr()
  //{ corr_val=trace(H); if (corr_val>H.rowdim()) corr_val=H.rowdim()/corr_val; else corr_val=1.;}
  {corr_val=CH_Matrix_Classes::min(1.,H.rowdim()/(H.rowdim()*weightu+trace(H)));}

public:

  BundleDenseTrustRegionProx(const CH_Matrix_Classes::Symmatrix& Hin,
                                VariableMetricSelection* vp=0,
                                bool local_metric=false,
                                bool bounds_scaling=false,
                                CBout* cb=0,
                                int cbinc=-1):
    BundleProxObject(vp,local_metric,bounds_scaling,cb,cbinc),
    H(Hin),is_factored(false)
  {weightu=1.;}

  BundleDenseTrustRegionProx(CH_Matrix_Classes::Integer dim=0,
                                VariableMetricSelection* vp=0,
                                bool local_metric=false,
                                bool bounds_scaling=false,
                                CBout* cb=0,
                                int cbinc=-1):
    BundleProxObject(vp,local_metric,bounds_scaling,cb,cbinc),
    H(dim,0.),is_factored(false)
  {assert(dim>=0);weightu=1.;}

  virtual ~BundleDenseTrustRegionProx(){}

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

  const CH_Matrix_Classes::Symmatrix& init(CH_Matrix_Classes::Symmatrix& in_H)
  {is_factored=false; return H=in_H;}

  bool get_factored() const {return is_factored;}

  const CH_Matrix_Classes::Symmatrix& get_H() const {return H;}
  
  const CH_Matrix_Classes::Symmatrix& get_Hchol() const {return Hchol;}

  CH_Matrix_Classes::Integer dim() const {return H.rowdim();}

  const CH_Matrix_Classes::Real& operator()(CH_Matrix_Classes::Integer i,CH_Matrix_Classes::Integer j)
  {return H(i,j);}
   
  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 false;}

  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
  { outplusHx.xpeya(x,weightu*alpha); return genmult(H,x,outplusHx,alpha,1.);}

  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
  { inD=diag(H); inD+=weightu; Vp=0; }


  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 ) 
  {
    CH_Matrix_Classes::Symmatrix S;
    H.principal_submatrix(indices,S);
    for(CH_Matrix_Classes::Integer i=0;i<S.rowdim();i++)
      S(i,i)-=weightu;
    BundleDenseTrustRegionProx* pp=new BundleDenseTrustRegionProx(S,0,get_use_local_metric(),get_use_bounds_scaling(),this,0);
    pp->set_weightu(weightu);
    pp->apply_factor(factor);
    if (get_variable_metric_selection())
      pp->set_variable_metric_selection(get_variable_metric_selection()->clone_VariableMetricSelection());
    return pp;
  }


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

  virtual bool supports_lowrank_variable_metric() const
  {return true;}

  virtual bool supports_diagonal_variable_metric() const
  {return true;}

  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::Symmatrix& addH);

  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