BundleDiagonalTrustRegionProx.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_BUNDLEDIAGONALTRUSTREGIONPROX_HXX
#define CONICBUNDLE_BUNDLEDIAGONALTRUSTREGIONPROX_HXX


#include "BundleProxObject.hxx"

namespace ConicBundle {


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

  CH_Matrix_Classes::Matrix D;

  CH_Matrix_Classes::Real corr_val;

  CH_Matrix_Classes::Matrix update_Dvalue;
  
  typedef std::map<MinorantPointer,CH_Matrix_Classes::Integer> MinorantPointerMap;
  MinorantPointerMap oldmap;

  CH_Matrix_Classes::Symmatrix oldQ;

  CH_Matrix_Classes::Indexmatrix old_fixed_ind;

  const CH_Matrix_Classes::Indexmatrix* new_indices;

  const CH_Matrix_Classes::Matrix* aggr;

  CH_Matrix_Classes::Matrix old_D;

  CH_Matrix_Classes::Real old_damping;

  std::vector<const AffineFunctionTransformation*> aft_stack;

  // CH_Matrix_Classes::Symmatrix last_Q;  ///< for testing updates 
  // CH_Matrix_Classes::Matrix last_d;     ///< for testing updates
  // CH_Matrix_Classes::Real last_offset;  ///< for testing updates

  
  void compute_corr()
  //{ corr_val=sum(D)-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));}

public:
  BundleDiagonalTrustRegionProx(const CH_Matrix_Classes::Matrix& Din,
                                VariableMetricSelection* vp=0,
                                bool local_scaling=false,
                                bool bounds_scaling=false,
                                CBout* cb=0,
                                int cbinc=-1):
    BundleProxObject(vp,local_scaling,bounds_scaling,cb,cbinc),
    weightu(1.),D(Din)
  {D+=weightu;compute_corr();}
  
  BundleDiagonalTrustRegionProx(CH_Matrix_Classes::Integer dim,
                                CH_Matrix_Classes::Real d,
                                VariableMetricSelection* vp=0,
                                bool local_scaling=false,
                                bool bounds_scaling=false,
                                CBout* cb=0,
                                int cbinc=-1):
    BundleProxObject(vp,local_scaling,bounds_scaling,cb,cbinc),
    weightu(1.),D(dim,1,weightu+d)
  {assert(dim>=0);assert(d>=0.);compute_corr();}

  BundleDiagonalTrustRegionProx(CH_Matrix_Classes::Integer dim=0,
                                VariableMetricSelection* vp=0,
                                bool local_scaling=false,
                                bool bounds_scaling=false,
                                CBout* cb=0,
                                int cbinc=-1):
    BundleProxObject(vp,local_scaling,bounds_scaling,cb,cbinc),
    weightu(1.),D(dim,1,weightu)
  {assert(dim>=0);compute_corr();}

  virtual ~BundleDiagonalTrustRegionProx(){}

  void set_weightu(CH_Matrix_Classes::Real in_weightu);

  CH_Matrix_Classes::Real get_weightu() const
  {return weightu*factor;}
  
  CH_Matrix_Classes::Real get_term_corr() const
  {return corr_val*factor;}

  const CH_Matrix_Classes::Matrix& get_D() const {return D;}

  void set_D(CH_Matrix_Classes::Matrix& in_D)
  {D=in_D+weightu;compute_corr();oldmap.clear();oldQ.init(0,0.);}

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

  CH_Matrix_Classes::Real operator()(CH_Matrix_Classes::Integer i) const {return D(i);}

  CH_Matrix_Classes::Real operator[](CH_Matrix_Classes::Integer i) const {return D[i];}
   
  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
  {return B.dual_norm_squared(&D)/factor;}
  
  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
  { return outplusHx.xpeya(D%x,alpha); }

  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=D; 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::Matrix tmpD=D(indices);
    tmpD-=weightu;
    BundleDiagonalTrustRegionProx* pp=new BundleDiagonalTrustRegionProx(tmpD,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 true;}
  
  virtual int diagonal_bounds_scaling_update(const CH_Matrix_Classes::Matrix& D_update)
  {
    assert(min(D_update)>=0.);
    update_Dvalue=D_update;D+=D_update;compute_corr();
    oldmap.clear();oldQ.init(0,0.);
    return 0;
  }
  
  virtual bool supports_lowrank_variable_metric() const {return false;}

  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