BundleDLRTrustRegionProx.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_DLRTRUSTREGIONPROX_HXX
#define CONICBUNDLE_DLRTRUSTREGIONPROX_HXX


#include "BundleProxObject.hxx"

namespace ConicBundle {


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

  CH_Matrix_Classes::Matrix D;

  CH_Matrix_Classes::Matrix vecH;

  mutable CH_Matrix_Classes::Matrix Dinv;

  mutable CH_Matrix_Classes::Matrix LinvHt;

  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;
  mutable CH_Matrix_Classes::Matrix indDinv;
  mutable CH_Matrix_Classes::Matrix indLinvHt;
  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 provide_inverse_data(bool skip_old_fixed_ind=false) const;

  void clear_inverse_data();

  void clean();

  void compute_corr()
  //{ corr_val=sum(D)+CH_Matrix_Classes::sqr(norm2(vecH))-weightu*D.dim(); if (corr_val>D.dim()) corr_val=D.dim()/corr_val; else corr_val=1.;}
  {corr_val=CH_Matrix_Classes::min(1.,D.rowdim()/(sum(D)+CH_Matrix_Classes::sqr(norm2(vecH))));}

public:
  BundleDLRTrustRegionProx(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.),D(dim,1,weightu),vecH(dim,0,0.)
  {assert(dim>=0);}

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

  virtual ~BundleDLRTrustRegionProx(){}

  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_D, 
            const CH_Matrix_Classes::Matrix& in_vecH);

  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_bounds_scaling_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 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::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