BundleRQBWeight.hxx

#ifndef CONICBUNDLE_BUNDLERQBWEIGHT_HXX
#define CONICBUNDLE_BUNDLERQBWEIGHT_HXX

#include "BundleWeight.hxx"

namespace ConicBundle {



class BundleRQBWeight: public BundleWeight
{
  Groundset* groundset;  
  BundleModel* model;    
  MinorantPointer center_aggr;  
  CH_Matrix_Classes::Real weight; 

  CH_Matrix_Classes::Real minweight; 
  CH_Matrix_Classes::Real maxweight; 
  
  bool weightchanged;    
  bool next_weight_set;  
  
  CH_Matrix_Classes::Real m1; 
  CH_Matrix_Classes::Real m2; 
  CH_Matrix_Classes::Real m3; 
  CH_Matrix_Classes::Real eta; 
  CH_Matrix_Classes::Real tL; 
  CH_Matrix_Classes::Real tR; 
  CH_Matrix_Classes::Real t; 
  CH_Matrix_Classes::Real frel; 
  CH_Matrix_Classes::Real delhat1; 

  int delta_subg(CH_Matrix_Classes::Matrix& delta_subg,MinorantPointer& center,MinorantPointer& cand);
    
public:
  BundleRQBWeight(BundleWeight* bwp=0,
                  const CBout* cbo=0,
                  int incr=-1);

  BundleRQBWeight(CH_Matrix_Classes::Real m1,
                  CH_Matrix_Classes::Real m2=.2,
                  CH_Matrix_Classes::Real m3=1.,
                  CH_Matrix_Classes::Real eta=1e-6,
                  BundleWeight* bwp=0,
                  const CBout* cbo=0,
                  int incr=-1);
  ~BundleRQBWeight(){}

 
  virtual void set_defaults(); 

  virtual void clear();        
  

  int init(CH_Matrix_Classes::Real aggr_dnmormsqr,Groundset* groundset,BundleModel* model);
  
  void set_next_weight(CH_Matrix_Classes::Real u)
  { if (u<=0.) return; 
  weight=CH_Matrix_Classes::max(u,1e-10); weightchanged=true;next_weight_set=true;}
  
  void set_minweight(CH_Matrix_Classes::Real mw)
  { 
    minweight=mw; 
    if (minweight>0){
      if ((weight>0)&&(weight<minweight))
        weight=minweight;
      if ((maxweight>0)&&(maxweight<minweight)) 
        maxweight=minweight;
    }
  }

  bool get_next_weight_set() const {return next_weight_set;}

  CH_Matrix_Classes::Real get_minweight() const {return minweight;}
  
  virtual void set_maxweight(CH_Matrix_Classes::Real mw)
  { 
    maxweight=mw; 
    if (maxweight>0){
      if (weight>maxweight){
        weight=maxweight;
      }
      if ((minweight>0)&&(minweight>maxweight)) 
        minweight=maxweight;
    }
  }
  
  CH_Matrix_Classes::Real get_maxweight() const {return maxweight;}

  CH_Matrix_Classes::Real get_weight() const;
  
  bool weight_changed() const;
  
  int descent_update(CH_Matrix_Classes::Real newval,
                     CH_Matrix_Classes::Real oldval,
                     CH_Matrix_Classes::Real modelval,
                     const CH_Matrix_Classes::Matrix& y, 
                     const CH_Matrix_Classes::Matrix& newy,
                     CH_Matrix_Classes::Real normsubg2,
                     BundleProxObject* Hp);
  
  int nullstep_update(CH_Matrix_Classes::Real newval,
                      CH_Matrix_Classes::Real oldval,
                      CH_Matrix_Classes::Real modelval,
                      const CH_Matrix_Classes::Matrix& y, 
                      const CH_Matrix_Classes::Matrix& newy,
                      MinorantPointer& new_minorant,
                      MinorantPointer& aggregate,
                      CH_Matrix_Classes::Real nullstep_bound,
                      CH_Matrix_Classes::Real normsubg2,
                      BundleProxObject *Hp);
      
  virtual int apply_modification(const GroundsetModification& gsmdf);

};

}

#endif