VariableMetric.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_VARIABLEMETRIC_HXX
#define CONICBUNDLE_VARIABLEMETRIC_HXX


#include "CBout.hxx"
#include "MinorantPointer.hxx"

namespace ConicBundle {

  class AffineFunctionTransformation;


  class VariableMetric;


class VariableMetricModel: public virtual CBout
{
public:
  VariableMetricModel(CBout* cb=0,int cbincr=-1);
  virtual ~VariableMetricModel();

  virtual int add_variable_metric(VariableMetric& H,
                                  CH_Matrix_Classes::Integer y_id ,
                                  const CH_Matrix_Classes::Matrix& y,
                                  bool descent_step ,
                                  CH_Matrix_Classes::Real weightu ,
                                  CH_Matrix_Classes::Real model_maxviol,
                                  const CH_Matrix_Classes::Indexmatrix* indices =0);

  virtual VariableMetricModel* variable_metric_transform() {return this;} 
  
};


class VariableMetricBundleData
{
private:
  CH_Matrix_Classes::Matrix vmbd_lowrankH; 
  CH_Matrix_Classes::Matrix vmbd_diagH; 
  CH_Matrix_Classes::Symmatrix vmbd_denseH; 

public:
  virtual ~VariableMetricBundleData();

  virtual CH_Matrix_Classes::Real get_function_factor() const=0;

  virtual int get_latest_minorants(MinorantBundle& latest_minorants,
                                   CH_Matrix_Classes::Integer max_number) =0;

  virtual int get_model_data(MinorantBundle& model_minorants,
                             CH_Matrix_Classes::Matrix& model_coeff) const=0;

  virtual const MinorantPointer& get_aggregate() const=0;

  virtual const CH_Matrix_Classes::Symmatrix& get_denseH() const
  {return vmbd_denseH;}

  virtual CH_Matrix_Classes::Symmatrix& set_denseH()
  {return vmbd_denseH;}

  virtual const CH_Matrix_Classes::Matrix& get_lowrankH() const
  {return vmbd_lowrankH;}

  virtual CH_Matrix_Classes::Matrix& set_lowrankH()
  {return vmbd_lowrankH;}

  virtual const CH_Matrix_Classes::Matrix& get_diagH() const
  {return vmbd_diagH;}

  virtual CH_Matrix_Classes::Matrix& set_diagH()
  {return vmbd_diagH;}
};

  
class VariableMetricSelection: public virtual CBout
{
public:
  VariableMetricSelection(CBout* cb=0,int cbincr=-1);
  virtual ~VariableMetricSelection(); 

  virtual int add_variable_metric(VariableMetric& H,
                                  CH_Matrix_Classes::Integer y_id ,
                                  const CH_Matrix_Classes::Matrix& y,
                                  bool descent_step,
                                  CH_Matrix_Classes::Real weightu,
                                  CH_Matrix_Classes::Real model_maxviol,
                                  const CH_Matrix_Classes::Indexmatrix* indices,
                                  VariableMetricBundleData& bundle_data)=0;

  virtual VariableMetricSelection* clone_VariableMetricSelection() =0;
                                  
};








class VariableMetric: public virtual CBout
{
private: 
  VariableMetricSelection* vm_selection;
  
  bool use_local_metric;
  
  bool use_bounds_scaling;

public:
  virtual ~VariableMetric();

  VariableMetric(VariableMetricSelection* vp=0,
                 bool use_loc_metric=false,
                 bool use_bnds_scaling=false,
                 CBout* cbo=0,int cbinc=-1):
    CBout(cbo,cbinc),
    vm_selection(vp),
    use_local_metric(use_loc_metric),
    use_bounds_scaling(use_bnds_scaling)
  {
    vm_selection=vp;
  }
  
  VariableMetricSelection* get_variable_metric_selection() const {return vm_selection;}

  void set_variable_metric_selection(VariableMetricSelection* vp=0)
  {delete vm_selection;vm_selection=vp;}

  virtual bool supports_dense_variable_metric() const
  {return false;}

  virtual bool supports_lowrank_variable_metric() const
  {return false;}

  virtual bool supports_diagonal_variable_metric() const
  {return false;}

  bool employ_variable_metric() const
  {return  (vm_selection)&&(supports_diagonal_variable_metric()||
            supports_lowrank_variable_metric()||
            supports_dense_variable_metric());}

  virtual int apply_variable_metric(VariableMetricModel* /* groundset */,
                                    VariableMetricModel* /* model */,
                                    const CH_Matrix_Classes::Matrix& /* aggregate */,
                                    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)
  {return 1;}
  
  virtual int add_variable_metric(CH_Matrix_Classes::Symmatrix& /* symH */)
  {return 1;}

  virtual int add_variable_metric(CH_Matrix_Classes::Matrix& /* diagH */,
                                  CH_Matrix_Classes::Matrix& /* vecH */)
  {return 1;}
  

  virtual int push_aft(const AffineFunctionTransformation* /* aft */)
  {return 1;}
  
  virtual int pop_aft()
  {return 1;}


  bool get_use_bounds_scaling() const {return use_bounds_scaling;}

  void set_use_bounds_scaling(bool bounds_scaling)
  {use_bounds_scaling=bounds_scaling;}

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

  bool get_use_local_metric() const {return use_local_metric;}

  void set_use_local_metric(bool local_metric)
  {use_local_metric=local_metric;}


};

    


}

#endif